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

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

@@ -0,0 +1,134 @@
+/*!
+ * @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, Optional } from '@angular/core';
+import { DateFnsUtils } from './date-fns-utils';
+import { DatetimeAdapter, MAT_DATETIME_FORMATS } from '@mat-datetimepicker/core';
+import { DateAdapter, MAT_DATE_LOCALE } from '@angular/material/core';
+import { addHours, addMinutes, isValid, parse } from 'date-fns';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/core";
+/**
+ * Material date/time formats for Date-fns (mat-datetimepicker)
+ */
+export const ADF_DATETIME_FORMATS = {
+    parse: {
+        dateInput: 'P', // L
+        monthInput: 'LLLL', // MMMM
+        timeInput: 'p', // LT
+        datetimeInput: 'Pp' // L LT
+    },
+    display: {
+        dateInput: 'P', // L
+        monthInput: 'LLLL', // MMMM
+        datetimeInput: 'Pp', // L LT
+        timeInput: 'p', // LT
+        monthYearLabel: 'LLL uuuu', // MMM YYYY
+        dateA11yLabel: 'PP', // LL
+        monthYearA11yLabel: 'LLLL uuuu', // MMMM YYYY
+        popupHeaderDateLabel: 'ccc, dd MMM' // ddd, DD MMM
+    }
+};
+/** The default hour names to use if Intl API is not available. */
+const DEFAULT_HOUR_NAMES = range(24, (i) => String(i));
+/** The default minute names to use if Intl API is not available. */
+const DEFAULT_MINUTE_NAMES = range(60, (i) => String(i));
+// eslint-disable-next-line jsdoc/require-jsdoc
+function range(length, valueFunction) {
+    const valuesArray = Array(length);
+    for (let i = 0; i < length; i++) {
+        valuesArray[i] = valueFunction(i);
+    }
+    return valuesArray;
+}
+export class AdfDateTimeFnsAdapter extends DatetimeAdapter {
+    get displayFormat() {
+        return this._displayFormat;
+    }
+    set displayFormat(value) {
+        this._displayFormat = value ? DateFnsUtils.convertMomentToDateFnsFormat(value) : null;
+    }
+    constructor(matDateLocale, formats, dateAdapter) {
+        super(dateAdapter);
+        this.formats = formats;
+        this._displayFormat = null;
+        this.setLocale(matDateLocale);
+    }
+    getHour(date) {
+        return date.getHours();
+    }
+    getMinute(date) {
+        return date.getMinutes();
+    }
+    getFirstDateOfMonth(date) {
+        const result = new Date();
+        result.setFullYear(date.getFullYear(), date.getMonth(), 1);
+        return result;
+    }
+    isInNextMonth(startDate, endDate) {
+        const nextMonth = this.getDateInNextMonth(startDate);
+        return this.sameMonthAndYear(nextMonth, endDate);
+    }
+    getHourNames() {
+        return DEFAULT_HOUR_NAMES;
+    }
+    getMinuteNames() {
+        return DEFAULT_MINUTE_NAMES;
+    }
+    addCalendarHours(date, hours) {
+        return addHours(date, hours);
+    }
+    addCalendarMinutes(date, minutes) {
+        return addMinutes(date, minutes);
+    }
+    createDatetime(year, month, date, hour, minute) {
+        const result = new Date();
+        result.setFullYear(year, month, date);
+        result.setHours(hour, minute, 0, 0);
+        return result;
+    }
+    getDateInNextMonth(date) {
+        return new Date(date.getFullYear(), date.getMonth() + 1, 1, date.getHours(), date.getMinutes());
+    }
+    parse(value, parseFormat) {
+        const dateToParse = isValid(new Date(value)) ? parse(value, this.displayFormat ?? parseFormat, new Date()) : value;
+        return this._delegate.parse(dateToParse, parseFormat);
+    }
+    format(date, displayFormat) {
+        displayFormat = DateFnsUtils.convertMomentToDateFnsFormat(displayFormat);
+        if (this.displayFormat && displayFormat === this.formats?.display?.datetimeInput) {
+            return this._delegate.format(date, this.displayFormat || displayFormat);
+        }
+        return this._delegate.format(date, displayFormat);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AdfDateTimeFnsAdapter, deps: [{ token: MAT_DATE_LOCALE, optional: true }, { token: MAT_DATETIME_FORMATS, optional: true }, { token: i1.DateAdapter }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AdfDateTimeFnsAdapter, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AdfDateTimeFnsAdapter, 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_DATETIME_FORMATS]
+                }] }, { type: i1.DateAdapter }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datetime-fns-adapter.js","sourceRoot":"","sources":["../../../../../../../lib/core/src/lib/common/utils/datetime-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 { Inject, Injectable, Optional } from '@angular/core';\nimport { DateFnsUtils } from './date-fns-utils';\nimport { DatetimeAdapter, MAT_DATETIME_FORMATS, MatDatetimeFormats } from '@mat-datetimepicker/core';\nimport { DateAdapter, MAT_DATE_LOCALE } from '@angular/material/core';\nimport { Locale, addHours, addMinutes, isValid, parse } from 'date-fns';\n\n/**\n * Material date/time formats for Date-fns (mat-datetimepicker)\n */\nexport const ADF_DATETIME_FORMATS: MatDatetimeFormats = {\n    parse: {\n        dateInput: 'P', // L\n        monthInput: 'LLLL', // MMMM\n        timeInput: 'p', // LT\n        datetimeInput: 'Pp' // L LT\n    },\n    display: {\n        dateInput: 'P', // L\n        monthInput: 'LLLL', // MMMM\n        datetimeInput: 'Pp', // L LT\n        timeInput: 'p', // LT\n        monthYearLabel: 'LLL uuuu', // MMM YYYY\n        dateA11yLabel: 'PP', // LL\n        monthYearA11yLabel: 'LLLL uuuu', // MMMM YYYY\n        popupHeaderDateLabel: 'ccc, dd MMM' // ddd, DD MMM\n    }\n};\n\n/** The default hour names to use if Intl API is not available. */\nconst DEFAULT_HOUR_NAMES = range(24, (i) => String(i));\n\n/** The default minute names to use if Intl API is not available. */\nconst DEFAULT_MINUTE_NAMES = range(60, (i) => String(i));\n\n// eslint-disable-next-line jsdoc/require-jsdoc\nfunction range<T>(length: number, valueFunction: (index: number) => T): T[] {\n    const valuesArray = Array(length);\n    for (let i = 0; i < length; i++) {\n        valuesArray[i] = valueFunction(i);\n    }\n    return valuesArray;\n}\n\n@Injectable({ providedIn: 'root' })\nexport class AdfDateTimeFnsAdapter extends DatetimeAdapter<Date> {\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_DATETIME_FORMATS) private formats: MatDatetimeFormats,\n        dateAdapter: DateAdapter<Date, Locale>\n    ) {\n        super(dateAdapter);\n        this.setLocale(matDateLocale);\n    }\n\n    getHour(date: Date): number {\n        return date.getHours();\n    }\n\n    getMinute(date: Date): number {\n        return date.getMinutes();\n    }\n\n    getFirstDateOfMonth(date: Date): Date {\n        const result = new Date();\n        result.setFullYear(date.getFullYear(), date.getMonth(), 1);\n        return result;\n    }\n\n    isInNextMonth(startDate: Date, endDate: Date): boolean {\n        const nextMonth = this.getDateInNextMonth(startDate);\n        return this.sameMonthAndYear(nextMonth, endDate);\n    }\n\n    getHourNames(): string[] {\n        return DEFAULT_HOUR_NAMES;\n    }\n\n    getMinuteNames(): string[] {\n        return DEFAULT_MINUTE_NAMES;\n    }\n\n    addCalendarHours(date: Date, hours: number): Date {\n        return addHours(date, hours);\n    }\n\n    addCalendarMinutes(date: Date, minutes: number): Date {\n        return addMinutes(date, minutes);\n    }\n\n    createDatetime(year: number, month: number, date: number, hour: number, minute: number): Date {\n        const result = new Date();\n        result.setFullYear(year, month, date);\n        result.setHours(hour, minute, 0, 0);\n        return result;\n    }\n\n    private getDateInNextMonth(date: Date) {\n        return new Date(date.getFullYear(), date.getMonth() + 1, 1, date.getHours(), date.getMinutes());\n    }\n\n    override parse(value: any, parseFormat: any): Date {\n        const dateToParse = isValid(new Date(value)) ? parse(value, this.displayFormat ?? parseFormat, new Date()) : value;\n        return this._delegate.parse(dateToParse, parseFormat);\n    }\n\n    override format(date: Date, displayFormat: any): string {\n        displayFormat = DateFnsUtils.convertMomentToDateFnsFormat(displayFormat);\n\n        if (this.displayFormat && displayFormat === this.formats?.display?.datetimeInput) {\n            return this._delegate.format(date, this.displayFormat || displayFormat);\n        }\n\n        return this._delegate.format(date, displayFormat);\n    }\n}\n"]}

package/esm2022/lib/common/utils/file-utils.mjs

@@ -0,0 +1,65 @@
+/*!
+ * @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.
+ */
+export class FileUtils {
+    static flatten(folder) {
+        const reader = folder.createReader();
+        const files = [];
+        return new Promise((resolve) => {
+            const iterations = [];
+            (function traverse() {
+                reader.readEntries((entries) => {
+                    if (!entries.length) {
+                        Promise.all(iterations).then(() => resolve(files));
+                    }
+                    else {
+                        iterations.push(Promise.all(entries.map((entry) => {
+                            if (entry.isFile) {
+                                return new Promise((resolveFile) => {
+                                    entry.file((file) => {
+                                        files.push({
+                                            entry,
+                                            file,
+                                            relativeFolder: entry.fullPath.replace(/\/[^/]*$/, '')
+                                        });
+                                        resolveFile();
+                                    });
+                                });
+                            }
+                            else {
+                                return FileUtils.flatten(entry).then((result) => {
+                                    files.push(...result);
+                                });
+                            }
+                        })));
+                        // Try calling traverse() again for the same dir, according to spec
+                        traverse();
+                    }
+                });
+            })();
+        });
+    }
+    static toFileArray(fileList) {
+        const result = [];
+        if (fileList && fileList.length > 0) {
+            for (let i = 0; i < fileList.length; i++) {
+                result.push(fileList[i]);
+            }
+        }
+        return result;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/common/utils/index.mjs

@@ -0,0 +1,18 @@
+/*!
+ * @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.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWIvY29yZS9zcmMvbGliL2NvbW1vbi91dGlscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

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

@@ -0,0 +1,202 @@
+/*!
+ * @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 { Injectable } from '@angular/core';
+import { DateAdapter } from '@angular/material/core';
+import { UserPreferencesService, UserPreferenceValues } from '../services/user-preferences.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/user-preferences.service";
+/**
+ * @deprecated this class is deprecated and should not be used.
+ * Consider using `AdfDateFnsAdapter` or `AdfDateTimeFnsAdapter` instead
+ */
+export class MomentDateAdapter extends DateAdapter {
+    constructor(preferences) {
+        super();
+        this.localeData = moment.localeData();
+        preferences.select(UserPreferenceValues.Locale).subscribe((locale) => {
+            this.setLocale(locale);
+        });
+    }
+    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?.format) {
+            return date.utc().local().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 (moment.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) {
+            // eslint-disable-next-line no-underscore-dangle
+            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();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MomentDateAdapter, deps: [{ token: i1.UserPreferencesService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MomentDateAdapter }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MomentDateAdapter, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.UserPreferencesService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"moment-date-adapter.js","sourceRoot":"","sources":["../../../../../../../lib/core/src/lib/common/utils/moment-date-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 { Injectable } from '@angular/core';\nimport { DateAdapter } from '@angular/material/core';\nimport { UserPreferencesService, UserPreferenceValues } from '../services/user-preferences.service';\n\n// Stub for the moment.js integration.\n// While this dependency is no longer used by the libraries, the moment adapter can still discover the moment.js linked to the application\ndeclare let moment: any;\ntype Moment = any;\n\n/**\n * @deprecated this class is deprecated and should not be used.\n * Consider using `AdfDateFnsAdapter` or `AdfDateTimeFnsAdapter` instead\n */\n@Injectable()\nexport class MomentDateAdapter extends DateAdapter<Moment> {\n    private localeData: any = moment.localeData();\n\n    overrideDisplayFormat: string;\n\n    constructor(preferences: UserPreferencesService) {\n        super();\n\n        preferences.select(UserPreferenceValues.Locale).subscribe((locale: string) => {\n            this.setLocale(locale);\n        });\n    }\n\n    getYear(date: Moment): number {\n        return date.year();\n    }\n\n    getMonth(date: Moment): number {\n        return date.month();\n    }\n\n    getDate(date: Moment): number {\n        return date.date();\n    }\n\n    getDayOfWeek(date: Moment): number {\n        return date.day();\n    }\n\n    getMonthNames(style: 'long' | 'short' | 'narrow'): string[] {\n        switch (style) {\n            case 'long':\n                return this.localeData.months();\n            case 'short':\n                return this.localeData.monthsShort();\n            case 'narrow':\n                return this.localeData.monthsShort().map((month) => month[0]);\n            default:\n                return [];\n        }\n    }\n\n    getDateNames(): string[] {\n        const dateNames: string[] = [];\n        for (let date = 1; date <= 31; date++) {\n            dateNames.push(String(date));\n        }\n\n        return dateNames;\n    }\n\n    getDayOfWeekNames(style: 'long' | 'short' | 'narrow'): string[] {\n        switch (style) {\n            case 'long':\n                return this.localeData.weekdays();\n            case 'short':\n                return this.localeData.weekdaysShort();\n            case 'narrow':\n                return this.localeData.weekdaysShort();\n            default:\n                return [];\n        }\n    }\n\n    getYearName(date: Moment): string {\n        return String(date.year());\n    }\n\n    getFirstDayOfWeek(): number {\n        return this.localeData.firstDayOfWeek();\n    }\n\n    getNumDaysInMonth(date: Moment): number {\n        return date.daysInMonth();\n    }\n\n    clone(date: Moment): Moment {\n        const locale = this.locale || 'en';\n        return date.clone().locale(locale);\n    }\n\n    createDate(year: number, month: number, date: number): Moment {\n        return moment([year, month, date]);\n    }\n\n    today(): Moment {\n        const locale = this.locale || 'en';\n        return moment().locale(locale);\n    }\n\n    parse(value: any, parseFormat: any): Moment {\n        const locale = this.locale || 'en';\n\n        if (value && typeof value === 'string') {\n            let m = moment(value, parseFormat, locale, true);\n            if (!m.isValid()) {\n                // use strict parsing because Moment's parser is very forgiving, and this can lead to undesired behavior.\n                m = moment(value, this.overrideDisplayFormat, locale, true);\n            }\n            if (m.isValid()) {\n                // if user omits year, it defaults to 2001, so check for that issue.\n                if (m.year() === 2001 && value.indexOf('2001') === -1) {\n                    // if 2001 not actually in the value string, change to current year\n                    const currentYear = new Date().getFullYear();\n                    m.set('year', currentYear);\n                    // if date is in the future, set previous year\n                    if (m.isAfter(moment())) {\n                        m.set('year', currentYear - 1);\n                    }\n                }\n            }\n            return m;\n        }\n\n        return value ? moment(value).locale(locale) : null;\n    }\n\n    format(date: Moment, displayFormat: any): string {\n        date = this.clone(date);\n        displayFormat = this.overrideDisplayFormat ? this.overrideDisplayFormat : displayFormat;\n\n        if (date?.format) {\n            return date.utc().local().format(displayFormat);\n        } else {\n            return '';\n        }\n    }\n\n    addCalendarYears(date: Moment, years: number): Moment {\n        return date.clone().add(years, 'y');\n    }\n\n    addCalendarMonths(date: Moment, months: number): Moment {\n        return date.clone().add(months, 'M');\n    }\n\n    addCalendarDays(date: Moment, days: number): Moment {\n        return date.clone().add(days, 'd');\n    }\n\n    getISODateString(date: Moment): string {\n        return date.toISOString();\n    }\n\n    setLocale(locale: any): void {\n        super.setLocale(locale);\n\n        this.localeData = moment.localeData(locale);\n    }\n\n    compareDate(first: Moment, second: Moment): number {\n        return first.diff(second, 'seconds', true);\n    }\n\n    sameDate(first: any | Moment, second: any | Moment): boolean {\n        if (first == null) {\n            // same if both null\n            return second == null;\n        } else if (moment.isMoment(first)) {\n            return first.isSame(second);\n        } else {\n            const isSame = super.sameDate(first, second);\n            return isSame;\n        }\n    }\n\n    clampDate(date: Moment, min?: any | Moment, max?: any | Moment): Moment {\n        if (min && date.isBefore(min)) {\n            return min;\n        } else if (max && date.isAfter(max)) {\n            return max;\n        } else {\n            return date;\n        }\n    }\n\n    isDateInstance(date: any) {\n        let isValidDateInstance = false;\n\n        if (date) {\n            // eslint-disable-next-line no-underscore-dangle\n            isValidDateInstance = date._isAMomentObject;\n        }\n\n        return isValidDateInstance;\n    }\n\n    isValid(date: Moment): boolean {\n        return date.isValid();\n    }\n\n    toIso8601(date: Moment): string {\n        return this.clone(date).format();\n    }\n\n    fromIso8601(iso8601String: string): Moment | null {\n        const locale = this.locale || 'en';\n        const d = moment(iso8601String, moment.ISO_8601).locale(locale);\n        return this.isValid(d) ? d : null;\n    }\n\n    invalid(): Moment {\n        return moment.invalid();\n    }\n}\n"]}

package/esm2022/lib/common/utils/moment-date-formats.model.mjs

@@ -0,0 +1,32 @@
+/*!
+ * @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.
+ */
+export const MOMENT_DATE_FORMATS = {
+    parse: {
+        dateInput: 'DD/MM/YYYY'
+    },
+    display: {
+        dateInput: 'DD/MM/YYYY',
+        monthYearLabel: 'MMMM Y',
+        dateA11yLabel: 'LL',
+        monthYearA11yLabel: 'MMMM Y'
+    }
+};
+const dateNames = [];
+for (let date = 1; date <= 31; date++) {
+    dateNames.push(String(date));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/common/utils/object-utils.mjs

@@ -0,0 +1,107 @@
+/*!
+ * @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.
+ */
+export class ObjectUtils {
+    /**
+     * Gets a value from an object by composed key
+     * ObjectUtils.getValue({ item: { nodeType: 'cm:folder' }}, 'item.nodeType') ==> 'cm:folder'
+     *
+     * @param target target object
+     * @param key object property key
+     * @returns object property value
+     */
+    static getValue(target, key) {
+        if (!target || !key) {
+            return undefined;
+        }
+        const keys = key.split('.');
+        key = '';
+        do {
+            key += keys.shift();
+            const value = target[key];
+            if (value !== undefined && (typeof value === 'object' || !keys.length)) {
+                target = value;
+                key = '';
+            }
+            else if (!keys.length) {
+                target = undefined;
+            }
+            else {
+                key += '.';
+            }
+        } while (keys.length);
+        return target;
+    }
+    static merge(...objects) {
+        const result = {};
+        objects.forEach((source) => {
+            Object.keys(source).forEach((prop) => {
+                if (prop in result && Array.isArray(result[prop])) {
+                    result[prop] = result[prop].concat(source[prop]);
+                }
+                else if (prop in result && typeof result[prop] === 'object') {
+                    result[prop] = ObjectUtils.merge(result[prop], source[prop]);
+                }
+                else {
+                    result[prop] = source[prop];
+                }
+            });
+        });
+        return result;
+    }
+    static isObject(target) {
+        return target === Object(target);
+    }
+    static isEmpty(target) {
+        return target && Object.keys(target).length === 0 && Object.getPrototypeOf(target) === Object.prototype;
+    }
+    static hasKeys(target) {
+        return target && Object.keys(target).length > 0;
+    }
+    static isBooleanObject(target) {
+        return Object.values(target).every((value) => typeof value === 'boolean');
+    }
+    static booleanPrettify(target, enhancer) {
+        if (!target || ObjectUtils.isEmpty(target) || !ObjectUtils.isBooleanObject(target)) {
+            return '';
+        }
+        if (!ObjectUtils.isObject(target) || !ObjectUtils.hasKeys(target)) {
+            return target.toString();
+        }
+        const greenBorderWhiteCheckSymbol = '&#9989';
+        const redCrossSymbol = '&#10060';
+        target = Object.keys(target)
+            .map((key) => {
+            if (target[key]) {
+                if (enhancer) {
+                    return `${greenBorderWhiteCheckSymbol} ${enhancer(key)}`;
+                }
+                else {
+                    return `${greenBorderWhiteCheckSymbol} ${key}`;
+                }
+            }
+            if (enhancer) {
+                return `${redCrossSymbol} ${enhancer(key)}`;
+            }
+            else {
+                return `${redCrossSymbol} ${key}`;
+            }
+        })
+            .join('\n');
+        return target;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"object-utils.js","sourceRoot":"","sources":["../../../../../../../lib/core/src/lib/common/utils/object-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\nexport class ObjectUtils {\n    /**\n     * Gets a value from an object by composed key\n     * ObjectUtils.getValue({ item: { nodeType: 'cm:folder' }}, 'item.nodeType') ==> 'cm:folder'\n     *\n     * @param target target object\n     * @param key object property key\n     * @returns object property value\n     */\n    static getValue(target: any, key: string): any {\n        if (!target || !key) {\n            return undefined;\n        }\n\n        const keys = key.split('.');\n        key = '';\n\n        do {\n            key += keys.shift();\n            const value = target[key];\n            if (value !== undefined && (typeof value === 'object' || !keys.length)) {\n                target = value;\n                key = '';\n            } else if (!keys.length) {\n                target = undefined;\n            } else {\n                key += '.';\n            }\n        } while (keys.length);\n\n        return target;\n    }\n\n    static merge(...objects): any {\n        const result = {};\n\n        objects.forEach((source) => {\n            Object.keys(source).forEach((prop) => {\n                if (prop in result && Array.isArray(result[prop])) {\n                    result[prop] = result[prop].concat(source[prop]);\n                } else if (prop in result && typeof result[prop] === 'object') {\n                    result[prop] = ObjectUtils.merge(result[prop], source[prop]);\n                } else {\n                    result[prop] = source[prop];\n                }\n            });\n        });\n\n        return result;\n    }\n\n    static isObject(target: any): boolean {\n        return target === Object(target);\n    }\n\n    static isEmpty(target: any): boolean {\n        return target && Object.keys(target).length === 0 && Object.getPrototypeOf(target) === Object.prototype;\n    }\n\n    static hasKeys(target: any): boolean {\n        return target && Object.keys(target).length > 0;\n    }\n\n    static isBooleanObject(target: any): boolean {\n        return Object.values(target).every((value) => typeof value === 'boolean');\n    }\n\n    static booleanPrettify(target: any, enhancer?: (param: string) => string): string {\n        if (!target || ObjectUtils.isEmpty(target) || !ObjectUtils.isBooleanObject(target)) {\n            return '';\n        }\n\n        if (!ObjectUtils.isObject(target) || !ObjectUtils.hasKeys(target)) {\n            return target.toString();\n        }\n\n        const greenBorderWhiteCheckSymbol = '&#9989';\n        const redCrossSymbol = '&#10060';\n\n        target = Object.keys(target)\n            .map((key) => {\n                if (target[key]) {\n                    if (enhancer) {\n                        return `${greenBorderWhiteCheckSymbol} ${enhancer(key)}`;\n                    } else {\n                        return `${greenBorderWhiteCheckSymbol} ${key}`;\n                    }\n                }\n\n                if (enhancer) {\n                    return `${redCrossSymbol} ${enhancer(key)}`;\n                } else {\n                    return `${redCrossSymbol} ${key}`;\n                }\n            })\n            .join('\\n');\n\n        return target;\n    }\n}\n"]}