raise-common-lib 0.0.248 → 0.0.249

package/esm2015/lib/date-tree-filter/date-tree-filter-popover/index.component.js

@@ -0,0 +1,761 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/date-tree-filter/date-tree-filter-popover/index.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Component, EventEmitter, Input, Output, } from "@angular/core";
+import moment from "moment";
+export class DateTreeFilterPopoverComponent {
+    constructor() {
+        this.field = "";
+        this.sourceRows = [];
+        this.dateFields = [];
+        this.selectedByField = {};
+        this.fieldLabelMap = {};
+        this.apply = new EventEmitter();
+        this.close = new EventEmitter();
+        this.keyword = "";
+        this.years = [];
+        this.expandStateByField = {};
+        this.workingSelectedByField = {};
+    }
+    /**
+     * @param {?} changes
+     * @return {?}
+     */
+    ngOnChanges(changes) {
+        if (changes.field ||
+            changes.sourceRows ||
+            changes.selectedByField ||
+            changes.dateFields) {
+            this.keyword = "";
+            this.workingSelectedByField = this.cloneSelectionMap(this.selectedByField);
+            this.rebuildTree();
+        }
+    }
+    /**
+     * @return {?}
+     */
+    closePopover() {
+        this.close.emit();
+    }
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    onKeywordChange(value) {
+        this.keyword = value || "";
+    }
+    /**
+     * @return {?}
+     */
+    getVisibleYears() {
+        /** @type {?} */
+        const searchText = (this.keyword || "").trim().toLowerCase();
+        if (!searchText) {
+            return this.years;
+        }
+        return this.years
+            .map((/**
+         * @param {?} yearNode
+         * @return {?}
+         */
+        (yearNode) => {
+            /** @type {?} */
+            const yearMatched = String(yearNode.year).toLowerCase().indexOf(searchText) > -1;
+            /** @type {?} */
+            const months = yearNode.months
+                .map((/**
+             * @param {?} monthNode
+             * @return {?}
+             */
+            (monthNode) => {
+                /** @type {?} */
+                const monthMatched = String(monthNode.label)
+                    .toLowerCase()
+                    .indexOf(searchText) > -1;
+                /** @type {?} */
+                const days = monthNode.days.filter((/**
+                 * @param {?} dayNode
+                 * @return {?}
+                 */
+                (dayNode) => {
+                    return (String(dayNode.label)
+                        .toLowerCase()
+                        .indexOf(searchText) > -1);
+                }));
+                if (yearMatched || monthMatched) {
+                    return monthNode;
+                }
+                return Object.assign({}, monthNode, { days: days });
+            }))
+                .filter((/**
+             * @param {?} monthNode
+             * @return {?}
+             */
+            (monthNode) => monthNode.days.length > 0));
+            if (yearMatched) {
+                return yearNode;
+            }
+            return Object.assign({}, yearNode, { months: months });
+        }))
+            .filter((/**
+         * @param {?} yearNode
+         * @return {?}
+         */
+        (yearNode) => yearNode.months.length > 0));
+    }
+    /**
+     * @param {?} yearNode
+     * @return {?}
+     */
+    toggleYearExpanded(yearNode) {
+        /** @type {?} */
+        const state = this.getOrCreateExpandState(this.field);
+        state.years[yearNode.key] = !state.years[yearNode.key];
+        yearNode.expanded = !!state.years[yearNode.key];
+    }
+    /**
+     * @param {?} monthNode
+     * @return {?}
+     */
+    toggleMonthExpanded(monthNode) {
+        /** @type {?} */
+        const state = this.getOrCreateExpandState(this.field);
+        state.months[monthNode.key] = !state.months[monthNode.key];
+        monthNode.expanded = !!state.months[monthNode.key];
+    }
+    /**
+     * @return {?}
+     */
+    isAllChecked() {
+        /** @type {?} */
+        const selectedMap = this.getFieldDaySelectionMap(this.field);
+        /** @type {?} */
+        const enabledDayKeys = this.getEnabledDayKeysInCurrentField();
+        if (!enabledDayKeys.length) {
+            return false;
+        }
+        return enabledDayKeys.every((/**
+         * @param {?} key
+         * @return {?}
+         */
+        (key) => !!selectedMap[key]));
+    }
+    /**
+     * @return {?}
+     */
+    isAllIndeterminate() {
+        /** @type {?} */
+        const selectedMap = this.getFieldDaySelectionMap(this.field);
+        /** @type {?} */
+        const enabledDayKeys = this.getEnabledDayKeysInCurrentField();
+        if (!enabledDayKeys.length) {
+            return false;
+        }
+        /** @type {?} */
+        const selectedCount = enabledDayKeys.filter((/**
+         * @param {?} key
+         * @return {?}
+         */
+        (key) => !!selectedMap[key]))
+            .length;
+        return selectedCount > 0 && selectedCount < enabledDayKeys.length;
+    }
+    /**
+     * @param {?} checked
+     * @return {?}
+     */
+    toggleAllDays(checked) {
+        /** @type {?} */
+        const selectedMap = this.getFieldDaySelectionMap(this.field);
+        /** @type {?} */
+        const enabledDayKeys = this.getEnabledDayKeysInCurrentField();
+        enabledDayKeys.forEach((/**
+         * @param {?} key
+         * @return {?}
+         */
+        (key) => {
+            if (checked) {
+                selectedMap[key] = true;
+            }
+            else {
+                delete selectedMap[key];
+            }
+        }));
+    }
+    /**
+     * @param {?} dayNode
+     * @return {?}
+     */
+    isDayChecked(dayNode) {
+        /** @type {?} */
+        const selectedMap = this.getFieldDaySelectionMap(this.field);
+        return !!selectedMap[dayNode.key];
+    }
+    /**
+     * @param {?} dayNode
+     * @param {?} checked
+     * @return {?}
+     */
+    toggleDay(dayNode, checked) {
+        if (dayNode.disabled) {
+            return;
+        }
+        /** @type {?} */
+        const selectedMap = this.getFieldDaySelectionMap(this.field);
+        if (checked) {
+            selectedMap[dayNode.key] = true;
+        }
+        else {
+            delete selectedMap[dayNode.key];
+        }
+    }
+    /**
+     * @param {?} monthNode
+     * @return {?}
+     */
+    isMonthDisabled(monthNode) {
+        return monthNode.days.every((/**
+         * @param {?} dayNode
+         * @return {?}
+         */
+        (dayNode) => dayNode.disabled));
+    }
+    /**
+     * @param {?} monthNode
+     * @return {?}
+     */
+    isMonthChecked(monthNode) {
+        if (this.isMonthDisabled(monthNode)) {
+            return false;
+        }
+        /** @type {?} */
+        const selectedMap = this.getFieldDaySelectionMap(this.field);
+        /** @type {?} */
+        const enabledDays = monthNode.days.filter((/**
+         * @param {?} dayNode
+         * @return {?}
+         */
+        (dayNode) => !dayNode.disabled));
+        return enabledDays.every((/**
+         * @param {?} dayNode
+         * @return {?}
+         */
+        (dayNode) => !!selectedMap[dayNode.key]));
+    }
+    /**
+     * @param {?} monthNode
+     * @return {?}
+     */
+    isMonthIndeterminate(monthNode) {
+        if (this.isMonthDisabled(monthNode)) {
+            return false;
+        }
+        /** @type {?} */
+        const selectedMap = this.getFieldDaySelectionMap(this.field);
+        /** @type {?} */
+        const enabledDays = monthNode.days.filter((/**
+         * @param {?} dayNode
+         * @return {?}
+         */
+        (dayNode) => !dayNode.disabled));
+        /** @type {?} */
+        const selectedCount = enabledDays.filter((/**
+         * @param {?} dayNode
+         * @return {?}
+         */
+        (dayNode) => {
+            return !!selectedMap[dayNode.key];
+        })).length;
+        return selectedCount > 0 && selectedCount < enabledDays.length;
+    }
+    /**
+     * @param {?} monthNode
+     * @param {?} checked
+     * @return {?}
+     */
+    toggleMonth(monthNode, checked) {
+        if (this.isMonthDisabled(monthNode)) {
+            return;
+        }
+        /** @type {?} */
+        const selectedMap = this.getFieldDaySelectionMap(this.field);
+        monthNode.days.forEach((/**
+         * @param {?} dayNode
+         * @return {?}
+         */
+        (dayNode) => {
+            if (dayNode.disabled) {
+                return;
+            }
+            if (checked) {
+                selectedMap[dayNode.key] = true;
+            }
+            else {
+                delete selectedMap[dayNode.key];
+            }
+        }));
+    }
+    /**
+     * @param {?} yearNode
+     * @return {?}
+     */
+    isYearDisabled(yearNode) {
+        return yearNode.months.every((/**
+         * @param {?} monthNode
+         * @return {?}
+         */
+        (monthNode) => this.isMonthDisabled(monthNode)));
+    }
+    /**
+     * @param {?} yearNode
+     * @return {?}
+     */
+    isYearChecked(yearNode) {
+        if (this.isYearDisabled(yearNode)) {
+            return false;
+        }
+        /** @type {?} */
+        const enabledMonths = yearNode.months.filter((/**
+         * @param {?} monthNode
+         * @return {?}
+         */
+        (monthNode) => !this.isMonthDisabled(monthNode)));
+        return enabledMonths.every((/**
+         * @param {?} monthNode
+         * @return {?}
+         */
+        (monthNode) => this.isMonthChecked(monthNode)));
+    }
+    /**
+     * @param {?} yearNode
+     * @return {?}
+     */
+    isYearIndeterminate(yearNode) {
+        if (this.isYearDisabled(yearNode)) {
+            return false;
+        }
+        /** @type {?} */
+        const selectedMap = this.getFieldDaySelectionMap(this.field);
+        /** @type {?} */
+        const enabledDays = [];
+        yearNode.months.forEach((/**
+         * @param {?} monthNode
+         * @return {?}
+         */
+        (monthNode) => {
+            monthNode.days.forEach((/**
+             * @param {?} dayNode
+             * @return {?}
+             */
+            (dayNode) => {
+                if (!dayNode.disabled) {
+                    enabledDays.push(dayNode.key);
+                }
+            }));
+        }));
+        /** @type {?} */
+        const selectedCount = enabledDays.filter((/**
+         * @param {?} key
+         * @return {?}
+         */
+        (key) => !!selectedMap[key])).length;
+        return selectedCount > 0 && selectedCount < enabledDays.length;
+    }
+    /**
+     * @param {?} yearNode
+     * @param {?} checked
+     * @return {?}
+     */
+    toggleYear(yearNode, checked) {
+        if (this.isYearDisabled(yearNode)) {
+            return;
+        }
+        yearNode.months.forEach((/**
+         * @param {?} monthNode
+         * @return {?}
+         */
+        (monthNode) => {
+            this.toggleMonth(monthNode, checked);
+        }));
+    }
+    /**
+     * @return {?}
+     */
+    clearSelection() {
+        if (this.field) {
+            this.workingSelectedByField[this.field] = {};
+        }
+        this.apply.emit(this.cloneSelectionMap(this.workingSelectedByField));
+        this.rebuildTree();
+    }
+    /**
+     * @return {?}
+     */
+    applySelection() {
+        this.apply.emit(this.cloneSelectionMap(this.workingSelectedByField));
+        this.closePopover();
+    }
+    /**
+     * @private
+     * @return {?}
+     */
+    rebuildTree() {
+        if (!this.field) {
+            this.years = [];
+            return;
+        }
+        /** @type {?} */
+        const sourceRows = this.sourceRows || [];
+        /** @type {?} */
+        const rowsByOtherFilters = this.filterRowsBySelectedDateTree(sourceRows, this.field);
+        /** @type {?} */
+        const availableDayKeyMap = {};
+        rowsByOtherFilters.forEach((/**
+         * @param {?} row
+         * @return {?}
+         */
+        (row) => {
+            /** @type {?} */
+            const dayKey = this.getDayKeyByRowValue(row[this.field]);
+            if (dayKey) {
+                availableDayKeyMap[dayKey] = true;
+            }
+        }));
+        /** @type {?} */
+        const groupedMap = {};
+        sourceRows.forEach((/**
+         * @param {?} row
+         * @return {?}
+         */
+        (row) => {
+            /** @type {?} */
+            const date = this.parseDateValue(row[this.field]);
+            if (!date) {
+                return;
+            }
+            /** @type {?} */
+            const year = date.getFullYear();
+            /** @type {?} */
+            const month = date.getMonth() + 1;
+            /** @type {?} */
+            const day = date.getDate();
+            if (!groupedMap[year]) {
+                groupedMap[year] = {};
+            }
+            if (!groupedMap[year][month]) {
+                groupedMap[year][month] = {};
+            }
+            if (!groupedMap[year][month][day]) {
+                groupedMap[year][month][day] = 0;
+            }
+            groupedMap[year][month][day] += 1;
+        }));
+        /** @type {?} */
+        const expandState = this.getOrCreateExpandState(this.field);
+        this.years = Object.keys(groupedMap)
+            .map((/**
+         * @param {?} key
+         * @return {?}
+         */
+        (key) => Number(key)))
+            .sort((/**
+         * @param {?} a
+         * @param {?} b
+         * @return {?}
+         */
+        (a, b) => b - a))
+            .map((/**
+         * @param {?} year
+         * @return {?}
+         */
+        (year) => {
+            /** @type {?} */
+            const months = Object.keys(groupedMap[year])
+                .map((/**
+             * @param {?} key
+             * @return {?}
+             */
+            (key) => Number(key)))
+                .sort((/**
+             * @param {?} a
+             * @param {?} b
+             * @return {?}
+             */
+            (a, b) => a - b))
+                .map((/**
+             * @param {?} month
+             * @return {?}
+             */
+            (month) => {
+                /** @type {?} */
+                const monthKey = year + "-" + this.pad2(month);
+                if (expandState.months[monthKey] === undefined) {
+                    expandState.months[monthKey] = true;
+                }
+                /** @type {?} */
+                const days = Object.keys(groupedMap[year][month])
+                    .map((/**
+                 * @param {?} key
+                 * @return {?}
+                 */
+                (key) => Number(key)))
+                    .sort((/**
+                 * @param {?} a
+                 * @param {?} b
+                 * @return {?}
+                 */
+                (a, b) => a - b))
+                    .map((/**
+                 * @param {?} day
+                 * @return {?}
+                 */
+                (day) => {
+                    /** @type {?} */
+                    const dayKey = this.toDayKey(year, month, day);
+                    /** @type {?} */
+                    const dayDate = new Date(year, month - 1, day);
+                    return {
+                        key: dayKey,
+                        day: day,
+                        label: moment(dayDate).format("D MMM YYYY"),
+                        count: groupedMap[year][month][day],
+                        disabled: !availableDayKeyMap[dayKey],
+                    };
+                }));
+                return {
+                    key: monthKey,
+                    month: month,
+                    label: moment()
+                        .month(month - 1)
+                        .format("MMM"),
+                    expanded: !!expandState.months[monthKey],
+                    days: days,
+                };
+            }));
+            /** @type {?} */
+            const yearKey = String(year);
+            if (expandState.years[yearKey] === undefined) {
+                expandState.years[yearKey] = true;
+            }
+            return {
+                key: yearKey,
+                year: year,
+                expanded: !!expandState.years[yearKey],
+                months: months,
+            };
+        }));
+    }
+    /**
+     * @private
+     * @param {?} rows
+     * @param {?=} excludeField
+     * @return {?}
+     */
+    filterRowsBySelectedDateTree(rows, excludeField) {
+        /** @type {?} */
+        let filteredRows = rows ? rows.slice() : [];
+        (this.dateFields || []).forEach((/**
+         * @param {?} field
+         * @return {?}
+         */
+        (field) => {
+            if (excludeField && field === excludeField) {
+                return;
+            }
+            /** @type {?} */
+            const selectedMap = this.getFieldDaySelectionMap(field);
+            /** @type {?} */
+            const selectedKeys = Object.keys(selectedMap);
+            if (!selectedKeys.length) {
+                return;
+            }
+            filteredRows = filteredRows.filter((/**
+             * @param {?} row
+             * @return {?}
+             */
+            (row) => {
+                /** @type {?} */
+                const dayKey = this.getDayKeyByRowValue(row[field]);
+                return dayKey ? !!selectedMap[dayKey] : false;
+            }));
+        }));
+        return filteredRows;
+    }
+    /**
+     * @private
+     * @param {?} value
+     * @return {?}
+     */
+    parseDateValue(value) {
+        if (!value) {
+            return null;
+        }
+        if (value instanceof Date) {
+            return value;
+        }
+        /** @type {?} */
+        const parsed = moment(value, [
+            "YYYY-MM-DD",
+            "MM/DD/YYYY",
+            "DD/MM/YYYY",
+            "YYYY/MM/DD",
+            "DD-MMM-YYYY",
+            "MMM DD, YYYY",
+            moment.ISO_8601,
+        ], true);
+        if (parsed.isValid()) {
+            return parsed.toDate();
+        }
+        /** @type {?} */
+        const fallback = new Date(value);
+        return isNaN(fallback.getTime()) ? null : fallback;
+    }
+    /**
+     * @private
+     * @param {?} field
+     * @return {?}
+     */
+    getOrCreateExpandState(field) {
+        if (!this.expandStateByField[field]) {
+            this.expandStateByField[field] = { years: {}, months: {} };
+        }
+        return this.expandStateByField[field];
+    }
+    /**
+     * @private
+     * @param {?} field
+     * @return {?}
+     */
+    getFieldDaySelectionMap(field) {
+        if (!this.workingSelectedByField[field]) {
+            this.workingSelectedByField[field] = {};
+        }
+        return this.workingSelectedByField[field];
+    }
+    /**
+     * @private
+     * @param {?} year
+     * @param {?} month
+     * @param {?} day
+     * @return {?}
+     */
+    toDayKey(year, month, day) {
+        return year + "-" + this.pad2(month) + "-" + this.pad2(day);
+    }
+    /**
+     * @private
+     * @param {?} value
+     * @return {?}
+     */
+    pad2(value) {
+        return value < 10 ? "0" + value : String(value);
+    }
+    /**
+     * @private
+     * @param {?} value
+     * @return {?}
+     */
+    getDayKeyByRowValue(value) {
+        /** @type {?} */
+        const date = this.parseDateValue(value);
+        if (!date) {
+            return "";
+        }
+        return this.toDayKey(date.getFullYear(), date.getMonth() + 1, date.getDate());
+    }
+    /**
+     * @private
+     * @return {?}
+     */
+    getEnabledDayKeysInCurrentField() {
+        /** @type {?} */
+        const keys = [];
+        this.years.forEach((/**
+         * @param {?} yearNode
+         * @return {?}
+         */
+        (yearNode) => {
+            yearNode.months.forEach((/**
+             * @param {?} monthNode
+             * @return {?}
+             */
+            (monthNode) => {
+                monthNode.days.forEach((/**
+                 * @param {?} dayNode
+                 * @return {?}
+                 */
+                (dayNode) => {
+                    if (!dayNode.disabled) {
+                        keys.push(dayNode.key);
+                    }
+                }));
+            }));
+        }));
+        return keys;
+    }
+    /**
+     * @private
+     * @param {?} source
+     * @return {?}
+     */
+    cloneSelectionMap(source) {
+        try {
+            return source ? JSON.parse(JSON.stringify(source)) : {};
+        }
+        catch (e) {
+            return {};
+        }
+    }
+}
+DateTreeFilterPopoverComponent.decorators = [
+    { type: Component, args: [{
+                selector: "rs-date-tree-filter-popover",
+                template: "<div class=\"date-tree-filter-popover\">\r\n    <div class=\"popover-search\">\r\n        <span class=\"search-icon\"><img src=\"/assets/img/search.svg\" alt=\"\" /></span>\r\n        <input\r\n            type=\"text\"\r\n            [placeholder]=\"translation.SEARCH || '.SEARCH'\"\r\n            [value]=\"keyword\"\r\n            (input)=\"onKeywordChange($event.target.value)\"\r\n        />\r\n    </div>\r\n\r\n    <div class=\"popover-tree\">\r\n        <label class=\"tree-row all-row\">\r\n            <input\r\n                type=\"checkbox\"\r\n                [checked]=\"isAllChecked()\"\r\n                [indeterminate]=\"isAllIndeterminate()\"\r\n                (change)=\"toggleAllDays($event.target.checked)\"\r\n            />\r\n            <span class=\"row-label\">{{ translation.ALL || '.ALL' }}</span>\r\n        </label>\r\n\r\n        <div class=\"year-block\" *ngFor=\"let yearNode of getVisibleYears()\">\r\n            <div class=\"tree-row\">\r\n                <button\r\n                    type=\"button\"\r\n                    class=\"tree-toggle-btn\"\r\n                    (click)=\"toggleYearExpanded(yearNode); $event.stopPropagation()\"\r\n                >\r\n                    <span class=\"tree-arrow\" [ngClass]=\"{ expanded: yearNode.expanded }\"></span>\r\n                </button>\r\n                <input\r\n                    type=\"checkbox\"\r\n                    [disabled]=\"isYearDisabled(yearNode)\"\r\n                    [checked]=\"isYearChecked(yearNode)\"\r\n                    [indeterminate]=\"isYearIndeterminate(yearNode)\"\r\n                    (change)=\"toggleYear(yearNode, $event.target.checked)\"\r\n                />\r\n                <span class=\"row-label\">{{ yearNode.year }}</span>\r\n            </div>\r\n\r\n            <div class=\"month-block\" *ngIf=\"yearNode.expanded\">\r\n                <div class=\"month-item\" *ngFor=\"let monthNode of yearNode.months\">\r\n                    <div class=\"tree-row\">\r\n                        <button\r\n                            type=\"button\"\r\n                            class=\"tree-toggle-btn\"\r\n                            (click)=\"toggleMonthExpanded(monthNode); $event.stopPropagation()\"\r\n                        >\r\n                            <span class=\"tree-arrow\" [ngClass]=\"{ expanded: monthNode.expanded }\"></span>\r\n                        </button>\r\n                        <input\r\n                            type=\"checkbox\"\r\n                            [disabled]=\"isMonthDisabled(monthNode)\"\r\n                            [checked]=\"isMonthChecked(monthNode)\"\r\n                            [indeterminate]=\"isMonthIndeterminate(monthNode)\"\r\n                            (change)=\"toggleMonth(monthNode, $event.target.checked)\"\r\n                        />\r\n                        <span class=\"row-label\">{{ monthNode.label }}</span>\r\n                    </div>\r\n\r\n                    <div class=\"day-block\" *ngIf=\"monthNode.expanded\">\r\n                        <label\r\n                            class=\"tree-row day-row\"\r\n                            *ngFor=\"let dayNode of monthNode.days\"\r\n                            [ngClass]=\"{ disabled: dayNode.disabled }\"\r\n                        >\r\n                            <span class=\"tree-toggle-spacer\"></span>\r\n                            <input\r\n                                type=\"checkbox\"\r\n                                [disabled]=\"dayNode.disabled\"\r\n                                [checked]=\"isDayChecked(dayNode)\"\r\n                                (change)=\"toggleDay(dayNode, $event.target.checked)\"\r\n                            />\r\n                            <span class=\"row-label\">{{ dayNode.label }}</span>\r\n                        </label>\r\n                    </div>\r\n                </div>\r\n            </div>\r\n        </div>\r\n    </div>\r\n\r\n    <div class=\"popover-footer\">\r\n        <button type=\"button\" (click)=\"clearSelection()\">\r\n            {{ translation.CLEAR || '.CLEAR' }}\r\n        </button>\r\n        <button type=\"button\" class=\"primary-btn\" (click)=\"applySelection()\">\r\n            {{ translation.APPLY || '.APPLY' }}\r\n        </button>\r\n    </div>\r\n</div>\r\n",
+                styles: [":host{position:fixed;left:12px;top:12px;z-index:20;width:300px}.date-tree-filter-popover{background:#fff;border:1px solid #eaedf0;border-radius:10px;box-shadow:0 0 4px rgba(0,0,0,.25);padding:4px 8px;display:flex;flex-direction:column;color:#44566c;font-family:Arial}.popover-search{position:relative;padding:4px 0 8px}.popover-search .search-icon{position:absolute;left:10px;top:10px;color:#929dab;font-size:12px;line-height:12px}.popover-search input{width:100%;height:28px;border:1px solid #eaedf0;border-radius:16px;padding:0 10px 0 28px;outline:0;font-size:12px;color:#44566c}.popover-tree{max-height:320px;overflow:auto;padding-right:2px}.tree-row{display:flex;align-items:center;min-height:24px;font-size:11px;line-height:14px;color:#44566c}.tree-row input[type=checkbox]{-webkit-appearance:none;-moz-appearance:none;appearance:none;width:14px;height:14px;margin:0 6px 0 0;box-sizing:border-box;border:1px solid #d8d8d8;border-radius:3px;background-color:#fff;cursor:pointer;vertical-align:middle;flex-shrink:0}.tree-row input[type=checkbox]:checked{border-color:#1f7bff;background-color:#1f7bff;background-image:url(\"data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='9' height='9' viewBox='0 0 9 9' fill='none'%3E%3Cpath d='M0.5 4.31818L3 7.5L5.75 4L8.5 0.5' stroke='white' stroke-linecap='round'/%3E%3C/svg%3E\");background-repeat:no-repeat;background-position:center;background-size:9px 9px}.tree-row input[type=checkbox]:indeterminate{border-color:#1f7bff;background-color:#1f7bff;background-image:url(\"data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='9' height='9' viewBox='0 0 9 9' fill='none'%3E%3Cpath d='M1.5 4.5H7.5' stroke='white' stroke-width='1.2' stroke-linecap='round'/%3E%3C/svg%3E\");background-repeat:no-repeat;background-position:center;background-size:9px 9px}.tree-row input[type=checkbox]:disabled{cursor:not-allowed;opacity:.5}.all-row{padding-left:20px;margin-bottom:2px}.year-block{margin-bottom:2px}.month-block{padding-left:20px}.day-block{padding-left:24px}.tree-toggle-btn{width:16px;height:16px;padding:0;margin-right:4px;border:none;background:0 0;display:inline-flex;align-items:center;justify-content:center;cursor:pointer}.tree-arrow{display:inline-block;width:6px;height:6px;border-right:1px solid #6c7c90;border-bottom:1px solid #6c7c90;transform:rotate(-45deg);transition:transform .15s}.tree-arrow.expanded{transform:rotate(45deg)}.tree-toggle-spacer{width:20px;display:inline-block}.row-label{color:#44566c}.day-row.disabled .row-label{color:#adb5bd}.popover-footer{margin-top:8px;padding:12px 0 8px;border-top:1px solid #eaedf0;display:flex;justify-content:flex-end;gap:12px}.popover-footer button{min-width:56px;height:26px;padding:0 8px;border-radius:4px;border:1px solid #dbe1e7;background:#fff;font-size:11px;color:#44566c;cursor:pointer}.popover-footer .primary-btn{background:#1364b3;border-color:#1364b3;color:#fff}"]
+            }] }
+];
+DateTreeFilterPopoverComponent.propDecorators = {
+    field: [{ type: Input }],
+    translation: [{ type: Input }],
+    sourceRows: [{ type: Input }],
+    dateFields: [{ type: Input }],
+    selectedByField: [{ type: Input }],
+    fieldLabelMap: [{ type: Input }],
+    apply: [{ type: Output }],
+    close: [{ type: Output }]
+};
+if (false) {
+    /** @type {?} */
+    DateTreeFilterPopoverComponent.prototype.field;
+    /** @type {?} */
+    DateTreeFilterPopoverComponent.prototype.translation;
+    /** @type {?} */
+    DateTreeFilterPopoverComponent.prototype.sourceRows;
+    /** @type {?} */
+    DateTreeFilterPopoverComponent.prototype.dateFields;
+    /** @type {?} */
+    DateTreeFilterPopoverComponent.prototype.selectedByField;
+    /** @type {?} */
+    DateTreeFilterPopoverComponent.prototype.fieldLabelMap;
+    /** @type {?} */
+    DateTreeFilterPopoverComponent.prototype.apply;
+    /** @type {?} */
+    DateTreeFilterPopoverComponent.prototype.close;
+    /** @type {?} */
+    DateTreeFilterPopoverComponent.prototype.keyword;
+    /** @type {?} */
+    DateTreeFilterPopoverComponent.prototype.years;
+    /**
+     * @type {?}
+     * @private
+     */
+    DateTreeFilterPopoverComponent.prototype.expandStateByField;
+    /**
+     * @type {?}
+     * @private
+     */
+    DateTreeFilterPopoverComponent.prototype.workingSelectedByField;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.component.js","sourceRoot":"ng://raise-common-lib/","sources":["lib/date-tree-filter/date-tree-filter-popover/index.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  Component,\r\n  EventEmitter,\r\n  Input,\r\n  OnChanges,\r\n  Output,\r\n  SimpleChanges,\r\n} from \"@angular/core\";\r\nimport moment from \"moment\";\r\n\r\n@Component({\r\n  selector: \"rs-date-tree-filter-popover\",\r\n  templateUrl: \"./index.component.html\",\r\n  styleUrls: [\"./index.component.scss\"],\r\n})\r\nexport class DateTreeFilterPopoverComponent implements OnChanges {\r\n  @Input() field = \"\";\r\n  @Input() translation: any;\r\n  @Input() sourceRows: any[] = [];\r\n  @Input() dateFields: string[] = [];\r\n  @Input() selectedByField: any = {};\r\n  @Input() fieldLabelMap: any = {};\r\n\r\n  @Output() apply = new EventEmitter<any>();\r\n  @Output() close = new EventEmitter<void>();\r\n\r\n  public keyword = \"\";\r\n  public years: any[] = [];\r\n\r\n  private expandStateByField: any = {};\r\n  private workingSelectedByField: any = {};\r\n\r\n  ngOnChanges(changes: SimpleChanges): void {\r\n    if (\r\n      changes.field ||\r\n      changes.sourceRows ||\r\n      changes.selectedByField ||\r\n      changes.dateFields\r\n    ) {\r\n      this.keyword = \"\";\r\n      this.workingSelectedByField = this.cloneSelectionMap(\r\n        this.selectedByField\r\n      );\r\n      this.rebuildTree();\r\n    }\r\n  }\r\n\r\n  public closePopover(): void {\r\n    this.close.emit();\r\n  }\r\n\r\n  public onKeywordChange(value: string): void {\r\n    this.keyword = value || \"\";\r\n  }\r\n\r\n  public getVisibleYears(): any[] {\r\n    const searchText = (this.keyword || \"\").trim().toLowerCase();\r\n    if (!searchText) {\r\n      return this.years;\r\n    }\r\n    return this.years\r\n      .map((yearNode) => {\r\n        const yearMatched =\r\n          String(yearNode.year).toLowerCase().indexOf(searchText) > -1;\r\n        const months = yearNode.months\r\n          .map((monthNode) => {\r\n            const monthMatched =\r\n              String(monthNode.label)\r\n                .toLowerCase()\r\n                .indexOf(searchText) > -1;\r\n            const days = monthNode.days.filter((dayNode) => {\r\n              return (\r\n                String(dayNode.label)\r\n                  .toLowerCase()\r\n                  .indexOf(searchText) > -1\r\n              );\r\n            });\r\n            if (yearMatched || monthMatched) {\r\n              return monthNode;\r\n            }\r\n            return Object.assign({}, monthNode, { days: days });\r\n          })\r\n          .filter((monthNode) => monthNode.days.length > 0);\r\n        if (yearMatched) {\r\n          return yearNode;\r\n        }\r\n        return Object.assign({}, yearNode, { months: months });\r\n      })\r\n      .filter((yearNode) => yearNode.months.length > 0);\r\n  }\r\n\r\n  public toggleYearExpanded(yearNode: any): void {\r\n    const state = this.getOrCreateExpandState(this.field);\r\n    state.years[yearNode.key] = !state.years[yearNode.key];\r\n    yearNode.expanded = !!state.years[yearNode.key];\r\n  }\r\n\r\n  public toggleMonthExpanded(monthNode: any): void {\r\n    const state = this.getOrCreateExpandState(this.field);\r\n    state.months[monthNode.key] = !state.months[monthNode.key];\r\n    monthNode.expanded = !!state.months[monthNode.key];\r\n  }\r\n\r\n  public isAllChecked(): boolean {\r\n    const selectedMap = this.getFieldDaySelectionMap(this.field);\r\n    const enabledDayKeys = this.getEnabledDayKeysInCurrentField();\r\n    if (!enabledDayKeys.length) {\r\n      return false;\r\n    }\r\n    return enabledDayKeys.every((key) => !!selectedMap[key]);\r\n  }\r\n\r\n  public isAllIndeterminate(): boolean {\r\n    const selectedMap = this.getFieldDaySelectionMap(this.field);\r\n    const enabledDayKeys = this.getEnabledDayKeysInCurrentField();\r\n    if (!enabledDayKeys.length) {\r\n      return false;\r\n    }\r\n    const selectedCount = enabledDayKeys.filter((key) => !!selectedMap[key])\r\n      .length;\r\n    return selectedCount > 0 && selectedCount < enabledDayKeys.length;\r\n  }\r\n\r\n  public toggleAllDays(checked: boolean): void {\r\n    const selectedMap = this.getFieldDaySelectionMap(this.field);\r\n    const enabledDayKeys = this.getEnabledDayKeysInCurrentField();\r\n    enabledDayKeys.forEach((key) => {\r\n      if (checked) {\r\n        selectedMap[key] = true;\r\n      } else {\r\n        delete selectedMap[key];\r\n      }\r\n    });\r\n  }\r\n\r\n  public isDayChecked(dayNode: any): boolean {\r\n    const selectedMap = this.getFieldDaySelectionMap(this.field);\r\n    return !!selectedMap[dayNode.key];\r\n  }\r\n\r\n  public toggleDay(dayNode: any, checked: boolean): void {\r\n    if (dayNode.disabled) {\r\n      return;\r\n    }\r\n    const selectedMap = this.getFieldDaySelectionMap(this.field);\r\n    if (checked) {\r\n      selectedMap[dayNode.key] = true;\r\n    } else {\r\n      delete selectedMap[dayNode.key];\r\n    }\r\n  }\r\n\r\n  public isMonthDisabled(monthNode: any): boolean {\r\n    return monthNode.days.every((dayNode) => dayNode.disabled);\r\n  }\r\n\r\n  public isMonthChecked(monthNode: any): boolean {\r\n    if (this.isMonthDisabled(monthNode)) {\r\n      return false;\r\n    }\r\n    const selectedMap = this.getFieldDaySelectionMap(this.field);\r\n    const enabledDays = monthNode.days.filter((dayNode) => !dayNode.disabled);\r\n    return enabledDays.every((dayNode) => !!selectedMap[dayNode.key]);\r\n  }\r\n\r\n  public isMonthIndeterminate(monthNode: any): boolean {\r\n    if (this.isMonthDisabled(monthNode)) {\r\n      return false;\r\n    }\r\n    const selectedMap = this.getFieldDaySelectionMap(this.field);\r\n    const enabledDays = monthNode.days.filter((dayNode) => !dayNode.disabled);\r\n    const selectedCount = enabledDays.filter((dayNode) => {\r\n      return !!selectedMap[dayNode.key];\r\n    }).length;\r\n    return selectedCount > 0 && selectedCount < enabledDays.length;\r\n  }\r\n\r\n  public toggleMonth(monthNode: any, checked: boolean): void {\r\n    if (this.isMonthDisabled(monthNode)) {\r\n      return;\r\n    }\r\n    const selectedMap = this.getFieldDaySelectionMap(this.field);\r\n    monthNode.days.forEach((dayNode) => {\r\n      if (dayNode.disabled) {\r\n        return;\r\n      }\r\n      if (checked) {\r\n        selectedMap[dayNode.key] = true;\r\n      } else {\r\n        delete selectedMap[dayNode.key];\r\n      }\r\n    });\r\n  }\r\n\r\n  public isYearDisabled(yearNode: any): boolean {\r\n    return yearNode.months.every((monthNode) =>\r\n      this.isMonthDisabled(monthNode)\r\n    );\r\n  }\r\n\r\n  public isYearChecked(yearNode: any): boolean {\r\n    if (this.isYearDisabled(yearNode)) {\r\n      return false;\r\n    }\r\n    const enabledMonths = yearNode.months.filter(\r\n      (monthNode) => !this.isMonthDisabled(monthNode)\r\n    );\r\n    return enabledMonths.every((monthNode) => this.isMonthChecked(monthNode));\r\n  }\r\n\r\n  public isYearIndeterminate(yearNode: any): boolean {\r\n    if (this.isYearDisabled(yearNode)) {\r\n      return false;\r\n    }\r\n    const selectedMap = this.getFieldDaySelectionMap(this.field);\r\n    const enabledDays = [];\r\n    yearNode.months.forEach((monthNode) => {\r\n      monthNode.days.forEach((dayNode) => {\r\n        if (!dayNode.disabled) {\r\n          enabledDays.push(dayNode.key);\r\n        }\r\n      });\r\n    });\r\n    const selectedCount = enabledDays.filter((key) => !!selectedMap[key]).length;\r\n    return selectedCount > 0 && selectedCount < enabledDays.length;\r\n  }\r\n\r\n  public toggleYear(yearNode: any, checked: boolean): void {\r\n    if (this.isYearDisabled(yearNode)) {\r\n      return;\r\n    }\r\n    yearNode.months.forEach((monthNode) => {\r\n      this.toggleMonth(monthNode, checked);\r\n    });\r\n  }\r\n\r\n  public clearSelection(): void {\r\n    if (this.field) {\r\n      this.workingSelectedByField[this.field] = {};\r\n    }\r\n    this.apply.emit(this.cloneSelectionMap(this.workingSelectedByField));\r\n    this.rebuildTree();\r\n  }\r\n\r\n  public applySelection(): void {\r\n    this.apply.emit(this.cloneSelectionMap(this.workingSelectedByField));\r\n    this.closePopover();\r\n  }\r\n\r\n  private rebuildTree(): void {\r\n    if (!this.field) {\r\n      this.years = [];\r\n      return;\r\n    }\r\n    const sourceRows = this.sourceRows || [];\r\n    const rowsByOtherFilters = this.filterRowsBySelectedDateTree(\r\n      sourceRows,\r\n      this.field\r\n    );\r\n    const availableDayKeyMap = {};\r\n    rowsByOtherFilters.forEach((row) => {\r\n      const dayKey = this.getDayKeyByRowValue(row[this.field]);\r\n      if (dayKey) {\r\n        availableDayKeyMap[dayKey] = true;\r\n      }\r\n    });\r\n\r\n    const groupedMap = {};\r\n    sourceRows.forEach((row) => {\r\n      const date = this.parseDateValue(row[this.field]);\r\n      if (!date) {\r\n        return;\r\n      }\r\n      const year = date.getFullYear();\r\n      const month = date.getMonth() + 1;\r\n      const day = date.getDate();\r\n      if (!groupedMap[year]) {\r\n        groupedMap[year] = {};\r\n      }\r\n      if (!groupedMap[year][month]) {\r\n        groupedMap[year][month] = {};\r\n      }\r\n      if (!groupedMap[year][month][day]) {\r\n        groupedMap[year][month][day] = 0;\r\n      }\r\n      groupedMap[year][month][day] += 1;\r\n    });\r\n\r\n    const expandState = this.getOrCreateExpandState(this.field);\r\n    this.years = Object.keys(groupedMap)\r\n      .map((key) => Number(key))\r\n      .sort((a, b) => b - a)\r\n      .map((year) => {\r\n        const months = Object.keys(groupedMap[year])\r\n          .map((key) => Number(key))\r\n          .sort((a, b) => a - b)\r\n          .map((month) => {\r\n            const monthKey = year + \"-\" + this.pad2(month);\r\n            if (expandState.months[monthKey] === undefined) {\r\n              expandState.months[monthKey] = true;\r\n            }\r\n            const days = Object.keys(groupedMap[year][month])\r\n              .map((key) => Number(key))\r\n              .sort((a, b) => a - b)\r\n              .map((day) => {\r\n                const dayKey = this.toDayKey(year, month, day);\r\n                const dayDate = new Date(year, month - 1, day);\r\n                return {\r\n                  key: dayKey,\r\n                  day: day,\r\n                  label: moment(dayDate).format(\"D MMM YYYY\"),\r\n                  count: groupedMap[year][month][day],\r\n                  disabled: !availableDayKeyMap[dayKey],\r\n                };\r\n              });\r\n            return {\r\n              key: monthKey,\r\n              month: month,\r\n              label: moment()\r\n                .month(month - 1)\r\n                .format(\"MMM\"),\r\n              expanded: !!expandState.months[monthKey],\r\n              days: days,\r\n            };\r\n          });\r\n        const yearKey = String(year);\r\n        if (expandState.years[yearKey] === undefined) {\r\n          expandState.years[yearKey] = true;\r\n        }\r\n        return {\r\n          key: yearKey,\r\n          year: year,\r\n          expanded: !!expandState.years[yearKey],\r\n          months: months,\r\n        };\r\n      });\r\n  }\r\n\r\n  private filterRowsBySelectedDateTree(rows: any[], excludeField?: string) {\r\n    let filteredRows = rows ? rows.slice() : [];\r\n    (this.dateFields || []).forEach((field) => {\r\n      if (excludeField && field === excludeField) {\r\n        return;\r\n      }\r\n      const selectedMap = this.getFieldDaySelectionMap(field);\r\n      const selectedKeys = Object.keys(selectedMap);\r\n      if (!selectedKeys.length) {\r\n        return;\r\n      }\r\n      filteredRows = filteredRows.filter((row) => {\r\n        const dayKey = this.getDayKeyByRowValue(row[field]);\r\n        return dayKey ? !!selectedMap[dayKey] : false;\r\n      });\r\n    });\r\n    return filteredRows;\r\n  }\r\n\r\n  private parseDateValue(value: any): Date {\r\n    if (!value) {\r\n      return null;\r\n    }\r\n    if (value instanceof Date) {\r\n      return value;\r\n    }\r\n    const parsed = moment(\r\n      value,\r\n      [\r\n        \"YYYY-MM-DD\",\r\n        \"MM/DD/YYYY\",\r\n        \"DD/MM/YYYY\",\r\n        \"YYYY/MM/DD\",\r\n        \"DD-MMM-YYYY\",\r\n        \"MMM DD, YYYY\",\r\n        moment.ISO_8601,\r\n      ],\r\n      true\r\n    );\r\n    if (parsed.isValid()) {\r\n      return parsed.toDate();\r\n    }\r\n    const fallback = new Date(value);\r\n    return isNaN(fallback.getTime()) ? null : fallback;\r\n  }\r\n\r\n  private getOrCreateExpandState(field: string) {\r\n    if (!this.expandStateByField[field]) {\r\n      this.expandStateByField[field] = { years: {}, months: {} };\r\n    }\r\n    return this.expandStateByField[field];\r\n  }\r\n\r\n  private getFieldDaySelectionMap(field: string) {\r\n    if (!this.workingSelectedByField[field]) {\r\n      this.workingSelectedByField[field] = {};\r\n    }\r\n    return this.workingSelectedByField[field];\r\n  }\r\n\r\n  private toDayKey(year: number, month: number, day: number) {\r\n    return year + \"-\" + this.pad2(month) + \"-\" + this.pad2(day);\r\n  }\r\n\r\n  private pad2(value: number) {\r\n    return value < 10 ? \"0\" + value : String(value);\r\n  }\r\n\r\n  private getDayKeyByRowValue(value: any) {\r\n    const date = this.parseDateValue(value);\r\n    if (!date) {\r\n      return \"\";\r\n    }\r\n    return this.toDayKey(\r\n      date.getFullYear(),\r\n      date.getMonth() + 1,\r\n      date.getDate()\r\n    );\r\n  }\r\n\r\n  private getEnabledDayKeysInCurrentField() {\r\n    const keys = [];\r\n    this.years.forEach((yearNode) => {\r\n      yearNode.months.forEach((monthNode) => {\r\n        monthNode.days.forEach((dayNode) => {\r\n          if (!dayNode.disabled) {\r\n            keys.push(dayNode.key);\r\n          }\r\n        });\r\n      });\r\n    });\r\n    return keys;\r\n  }\r\n\r\n  private cloneSelectionMap(source: any) {\r\n    try {\r\n      return source ? JSON.parse(JSON.stringify(source)) : {};\r\n    } catch (e) {\r\n      return {};\r\n    }\r\n  }\r\n}\r\n"]}