raise-common-lib 0.0.248 → 0.0.249

package/esm5/lib/date-tree-filter/date-tree-filter.helper.js

@@ -0,0 +1,787 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/date-tree-filter/date-tree-filter.helper.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import moment from "moment";
+/**
+ * @record
+ */
+export function DateTreeFilterSetupOptions() { }
+if (false) {
+    /** @type {?} */
+    DateTreeFilterSetupOptions.prototype.rows;
+    /** @type {?} */
+    DateTreeFilterSetupOptions.prototype.fields;
+    /** @type {?} */
+    DateTreeFilterSetupOptions.prototype.hints;
+}
+/**
+ * @record
+ */
+export function DateTreeFilterHelperOptions() { }
+if (false) {
+    /** @type {?} */
+    DateTreeFilterHelperOptions.prototype.getTranslation;
+    /** @type {?} */
+    DateTreeFilterHelperOptions.prototype.getPopoverElement;
+    /** @type {?} */
+    DateTreeFilterHelperOptions.prototype.getGridElement;
+    /** @type {?} */
+    DateTreeFilterHelperOptions.prototype.applyRows;
+    /** @type {?|undefined} */
+    DateTreeFilterHelperOptions.prototype.parseDateValue;
+    /** @type {?|undefined} */
+    DateTreeFilterHelperOptions.prototype.dateFormats;
+}
+/**
+ * @record
+ */
+export function RsCommonGridDateTreeFactoryHost() { }
+if (false) {
+    /** @type {?} */
+    RsCommonGridDateTreeFactoryHost.prototype.translation;
+    /** @type {?} */
+    RsCommonGridDateTreeFactoryHost.prototype.dateTreePopoverRef;
+    /** @type {?} */
+    RsCommonGridDateTreeFactoryHost.prototype.grid;
+}
+/** @type {?} */
+export var DATE_TREE_DEFAULT_DATE_FORMATS = [
+    "YYYY-MM-DD",
+    "MM/DD/YYYY",
+    "DD/MM/YYYY",
+    "YYYY/MM/DD",
+    "DD-MMM-YYYY",
+    "MMM DD, YYYY",
+];
+var DateTreeFilterHelper = /** @class */ (function () {
+    function DateTreeFilterHelper(options) {
+        this.popoverVisible = false;
+        this.popoverField = "";
+        this.popoverStyle = {};
+        this.selectedByField = {};
+        this.fieldLabelMap = {};
+        this.dateFields = [];
+        this.sourceRows = [];
+        this.defaultDateFormats = [
+            "YYYY-MM-DD",
+            "MM/DD/YYYY",
+            "DD/MM/YYYY",
+            "YYYY/MM/DD",
+            "DD-MMM-YYYY",
+            "DD-MMM-YYYY hh:mm A",
+            "MMM DD, YYYY",
+            moment.ISO_8601,
+        ];
+        this.options = options;
+    }
+    /**
+     * @param {?} config
+     * @return {?}
+     */
+    DateTreeFilterHelper.prototype.setup = /**
+     * @param {?} config
+     * @return {?}
+     */
+    function (config) {
+        var _this = this;
+        /** @type {?} */
+        var rows = config && config.rows ? config.rows : [];
+        /** @type {?} */
+        var fields = config && config.fields ? config.fields : [];
+        /** @type {?} */
+        var hints = config && config.hints ? config.hints : [];
+        this.sourceRows = rows;
+        this.dateFields = this.resolveDateTreeFieldsByHints(fields, hints);
+        this.fieldLabelMap = {};
+        (fields || []).forEach((/**
+         * @param {?} item
+         * @return {?}
+         */
+        function (item) {
+            if (!item || !item.columnName) {
+                return;
+            }
+            _this.fieldLabelMap[item.columnName] =
+                item.columnDisplayName || item.columnName;
+        }));
+        this.apply();
+    };
+    /**
+     * @param {?} args
+     * @return {?}
+     */
+    DateTreeFilterHelper.prototype.handleGridActionBegin = /**
+     * @param {?} args
+     * @return {?}
+     */
+    function (args) {
+        /** @type {?} */
+        var requestType = this.getRequestType(args);
+        if (requestType === "filterchoicerequest" ||
+            requestType === "filtersearchbegin") {
+            args.filterChoiceCount = 15000;
+        }
+        if (requestType !== "filterbeforeopen") {
+            return;
+        }
+        /** @type {?} */
+        var columnName = this.resolveActionColumnName(args);
+        if (!this.isDateTreeField(columnName)) {
+            this.close();
+            return;
+        }
+        args.cancel = true;
+        this.open(columnName);
+    };
+    /**
+     * @param {?} selectionMap
+     * @return {?}
+     */
+    DateTreeFilterHelper.prototype.updateSelection = /**
+     * @param {?} selectionMap
+     * @return {?}
+     */
+    function (selectionMap) {
+        this.selectedByField = selectionMap || {};
+        this.apply();
+    };
+    /**
+     * @return {?}
+     */
+    DateTreeFilterHelper.prototype.close = /**
+     * @return {?}
+     */
+    function () {
+        if (!this.popoverVisible) {
+            return;
+        }
+        this.popoverVisible = false;
+        this.popoverField = "";
+        this.popoverStyle = {};
+    };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    DateTreeFilterHelper.prototype.handleDocumentMouseDown = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        if (!this.popoverVisible) {
+            return;
+        }
+        /** @type {?} */
+        var target = (/** @type {?} */ (event.target));
+        if (!target) {
+            return;
+        }
+        if (this.isInsidePopover(target) || this.isDateFilterMenuItem(target)) {
+            return;
+        }
+        this.close();
+    };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    DateTreeFilterHelper.prototype.handleDocumentMouseOver = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        if (!this.popoverVisible) {
+            return;
+        }
+        /** @type {?} */
+        var target = (/** @type {?} */ (event.target));
+        if (!target) {
+            return;
+        }
+        if (this.isInsidePopover(target)) {
+            return;
+        }
+        /** @type {?} */
+        var menuItem = (/** @type {?} */ (target.closest(".e-menu-item")));
+        if (menuItem) {
+            if (!this.isDateFilterMenuItem(menuItem)) {
+                this.close();
+            }
+            return;
+        }
+        /** @type {?} */
+        var otherFilterTarget = (/** @type {?} */ (target.closest(".e-filtermenudiv, .e-headercell .e-columnmenu, .e-columnmenu, .e-contextmenu")));
+        if (otherFilterTarget && !this.isDateFilterMenuItem(otherFilterTarget)) {
+            this.close();
+        }
+    };
+    /**
+     * @return {?}
+     */
+    DateTreeFilterHelper.prototype.updatePosition = /**
+     * @return {?}
+     */
+    function () {
+        if (!this.popoverVisible) {
+            return;
+        }
+        /** @type {?} */
+        var anchor = this.findDateFilterAnchorElement();
+        if (anchor) {
+            /** @type {?} */
+            var rect = anchor.getBoundingClientRect();
+            /** @type {?} */
+            var viewportWidth = window.innerWidth || document.documentElement.clientWidth;
+            /** @type {?} */
+            var viewportHeight = window.innerHeight || document.documentElement.clientHeight;
+            /** @type {?} */
+            var popoverElement = this.options.getPopoverElement
+                ? this.options.getPopoverElement()
+                : null;
+            /** @type {?} */
+            var popoverWidth = popoverElement && popoverElement.offsetWidth
+                ? popoverElement.offsetWidth
+                : 300;
+            /** @type {?} */
+            var popoverHeight = popoverElement && popoverElement.offsetHeight
+                ? popoverElement.offsetHeight
+                : 420;
+            /** @type {?} */
+            var edgeGap = 8;
+            /** @type {?} */
+            var anchorGap = 8;
+            /** @type {?} */
+            var top = rect.top - 6;
+            /** @type {?} */
+            var left = rect.right + anchorGap;
+            if (left + popoverWidth > viewportWidth - edgeGap) {
+                left = rect.left - popoverWidth - anchorGap;
+            }
+            if (left < edgeGap) {
+                left = edgeGap;
+            }
+            if (left + popoverWidth > viewportWidth - edgeGap) {
+                left = Math.max(edgeGap, viewportWidth - popoverWidth - edgeGap);
+            }
+            if (top + popoverHeight > viewportHeight - edgeGap) {
+                top = Math.max(edgeGap, viewportHeight - popoverHeight - edgeGap);
+            }
+            this.popoverStyle = {
+                position: "fixed",
+                left: left + "px",
+                top: top + "px",
+            };
+            return;
+        }
+        /** @type {?} */
+        var gridElement = this.options.getGridElement
+            ? this.options.getGridElement()
+            : null;
+        if (gridElement && gridElement.getBoundingClientRect) {
+            /** @type {?} */
+            var fallbackRect = gridElement.getBoundingClientRect();
+            this.popoverStyle = {
+                position: "fixed",
+                left: Math.max(8, fallbackRect.right - 312) + "px",
+                top: Math.max(8, fallbackRect.top + 8) + "px",
+            };
+        }
+    };
+    /**
+     * @private
+     * @param {?} field
+     * @return {?}
+     */
+    DateTreeFilterHelper.prototype.open = /**
+     * @private
+     * @param {?} field
+     * @return {?}
+     */
+    function (field) {
+        var _this = this;
+        this.popoverField = field;
+        this.popoverVisible = true;
+        this.updatePosition();
+        setTimeout((/**
+         * @return {?}
+         */
+        function () { return _this.updatePosition(); }), 50);
+        setTimeout((/**
+         * @return {?}
+         */
+        function () { return _this.updatePosition(); }), 150);
+    };
+    /**
+     * @private
+     * @return {?}
+     */
+    DateTreeFilterHelper.prototype.apply = /**
+     * @private
+     * @return {?}
+     */
+    function () {
+        /** @type {?} */
+        var filteredRows = this.filterRowsBySelectedDateTree(this.sourceRows || []);
+        this.options.applyRows(filteredRows);
+    };
+    /**
+     * @private
+     * @param {?} args
+     * @return {?}
+     */
+    DateTreeFilterHelper.prototype.getRequestType = /**
+     * @private
+     * @param {?} args
+     * @return {?}
+     */
+    function (args) {
+        if (!args || !args.requestType) {
+            return "";
+        }
+        return String(args.requestType).trim().toLowerCase();
+    };
+    /**
+     * @private
+     * @param {?} args
+     * @return {?}
+     */
+    DateTreeFilterHelper.prototype.resolveActionColumnName = /**
+     * @private
+     * @param {?} args
+     * @return {?}
+     */
+    function (args) {
+        if (!args) {
+            return "";
+        }
+        return (args.columnName ||
+            args.field ||
+            args.currentFilteringColumn ||
+            (args.column && (args.column.field || args.column.columnName)) ||
+            "");
+    };
+    /**
+     * @private
+     * @param {?} fields
+     * @param {?} hints
+     * @return {?}
+     */
+    DateTreeFilterHelper.prototype.resolveDateTreeFieldsByHints = /**
+     * @private
+     * @param {?} fields
+     * @param {?} hints
+     * @return {?}
+     */
+    function (fields, hints) {
+        /** @type {?} */
+        var normalizedHints = (hints || [])
+            .filter((/**
+         * @param {?} item
+         * @return {?}
+         */
+        function (item) { return !!item; }))
+            .map((/**
+         * @param {?} item
+         * @return {?}
+         */
+        function (item) { return String(item).trim().toLowerCase(); }));
+        if (!fields || !fields.length || !normalizedHints.length) {
+            return [];
+        }
+        return fields
+            .filter((/**
+         * @param {?} item
+         * @return {?}
+         */
+        function (item) {
+            if (!item || !item.columnName) {
+                return false;
+            }
+            /** @type {?} */
+            var columnName = String(item.columnName || "").toLowerCase();
+            /** @type {?} */
+            var displayName = String(item.columnDisplayName || "").toLowerCase();
+            return normalizedHints.some((/**
+             * @param {?} hint
+             * @return {?}
+             */
+            function (hint) {
+                return (columnName === hint ||
+                    displayName === hint ||
+                    (hint.length >= 3 &&
+                        (columnName.indexOf(hint) > -1 ||
+                            displayName.indexOf(hint) > -1)));
+            }));
+        }))
+            .map((/**
+         * @param {?} item
+         * @return {?}
+         */
+        function (item) { return item.columnName; }));
+    };
+    /**
+     * @private
+     * @param {?} field
+     * @return {?}
+     */
+    DateTreeFilterHelper.prototype.isDateTreeField = /**
+     * @private
+     * @param {?} field
+     * @return {?}
+     */
+    function (field) {
+        return this.dateFields.indexOf(field) > -1;
+    };
+    /**
+     * @private
+     * @param {?} field
+     * @return {?}
+     */
+    DateTreeFilterHelper.prototype.getFieldDaySelectionMap = /**
+     * @private
+     * @param {?} field
+     * @return {?}
+     */
+    function (field) {
+        if (!this.selectedByField[field]) {
+            this.selectedByField[field] = {};
+        }
+        return this.selectedByField[field];
+    };
+    /**
+     * @private
+     * @param {?} rows
+     * @param {?=} excludeField
+     * @return {?}
+     */
+    DateTreeFilterHelper.prototype.filterRowsBySelectedDateTree = /**
+     * @private
+     * @param {?} rows
+     * @param {?=} excludeField
+     * @return {?}
+     */
+    function (rows, excludeField) {
+        var _this = this;
+        /** @type {?} */
+        var filteredRows = rows ? rows.slice() : [];
+        this.dateFields.forEach((/**
+         * @param {?} field
+         * @return {?}
+         */
+        function (field) {
+            if (excludeField && field === excludeField) {
+                return;
+            }
+            /** @type {?} */
+            var selectedMap = _this.getFieldDaySelectionMap(field);
+            /** @type {?} */
+            var selectedKeys = Object.keys(selectedMap);
+            if (!selectedKeys.length) {
+                return;
+            }
+            filteredRows = filteredRows.filter((/**
+             * @param {?} row
+             * @return {?}
+             */
+            function (row) {
+                /** @type {?} */
+                var dayKey = _this.getDayKeyByRowValue(row[field]);
+                return dayKey ? !!selectedMap[dayKey] : false;
+            }));
+        }));
+        return filteredRows;
+    };
+    /**
+     * @private
+     * @param {?} value
+     * @return {?}
+     */
+    DateTreeFilterHelper.prototype.getDayKeyByRowValue = /**
+     * @private
+     * @param {?} value
+     * @return {?}
+     */
+    function (value) {
+        /** @type {?} */
+        var date = this.parseDateValue(value);
+        if (!date) {
+            return "";
+        }
+        return this.toDayKey(date.getFullYear(), date.getMonth() + 1, date.getDate());
+    };
+    /**
+     * @private
+     * @param {?} value
+     * @return {?}
+     */
+    DateTreeFilterHelper.prototype.parseDateValue = /**
+     * @private
+     * @param {?} value
+     * @return {?}
+     */
+    function (value) {
+        if (this.options.parseDateValue) {
+            return this.options.parseDateValue(value);
+        }
+        if (!value) {
+            return null;
+        }
+        if (value instanceof Date) {
+            return value;
+        }
+        /** @type {?} */
+        var formats = this.options && this.options.dateFormats && this.options.dateFormats.length
+            ? this.options.dateFormats
+            : this.defaultDateFormats;
+        /** @type {?} */
+        var parsed = moment(value, formats, true);
+        if (parsed.isValid()) {
+            return parsed.toDate();
+        }
+        /** @type {?} */
+        var fallback = new Date(value);
+        return isNaN(fallback.getTime()) ? null : fallback;
+    };
+    /**
+     * @private
+     * @param {?} year
+     * @param {?} month
+     * @param {?} day
+     * @return {?}
+     */
+    DateTreeFilterHelper.prototype.toDayKey = /**
+     * @private
+     * @param {?} year
+     * @param {?} month
+     * @param {?} day
+     * @return {?}
+     */
+    function (year, month, day) {
+        return year + "-" + this.pad2(month) + "-" + this.pad2(day);
+    };
+    /**
+     * @private
+     * @param {?} value
+     * @return {?}
+     */
+    DateTreeFilterHelper.prototype.pad2 = /**
+     * @private
+     * @param {?} value
+     * @return {?}
+     */
+    function (value) {
+        return value < 10 ? "0" + value : String(value);
+    };
+    /**
+     * @private
+     * @param {?} target
+     * @return {?}
+     */
+    DateTreeFilterHelper.prototype.isInsidePopover = /**
+     * @private
+     * @param {?} target
+     * @return {?}
+     */
+    function (target) {
+        /** @type {?} */
+        var popoverElement = this.options.getPopoverElement
+            ? this.options.getPopoverElement()
+            : null;
+        if (!target || !popoverElement) {
+            return false;
+        }
+        return popoverElement.contains(target);
+    };
+    /**
+     * @private
+     * @param {?} element
+     * @return {?}
+     */
+    DateTreeFilterHelper.prototype.isDateFilterMenuItem = /**
+     * @private
+     * @param {?} element
+     * @return {?}
+     */
+    function (element) {
+        if (!element) {
+            return false;
+        }
+        /** @type {?} */
+        var menuItem = (/** @type {?} */ (element.closest(".e-menu-item")));
+        if (!menuItem) {
+            return false;
+        }
+        /** @type {?} */
+        var text = (menuItem.textContent || "").trim().toLowerCase();
+        /** @type {?} */
+        var translation = this.options.getTranslation
+            ? this.options.getTranslation()
+            : null;
+        /** @type {?} */
+        var filterText = String((translation && translation.FILTER) || "filter")
+            .trim()
+            .toLowerCase();
+        if (!text) {
+            return false;
+        }
+        if (text.indexOf(filterText) > -1 || text.indexOf("filter") > -1) {
+            return true;
+        }
+        /** @type {?} */
+        var cls = (menuItem.className || "").toLowerCase();
+        return cls.indexOf("filter") > -1;
+    };
+    /**
+     * @private
+     * @return {?}
+     */
+    DateTreeFilterHelper.prototype.findDateFilterAnchorElement = /**
+     * @private
+     * @return {?}
+     */
+    function () {
+        var _this = this;
+        /** @type {?} */
+        var menuContainers = (/** @type {?} */ (Array.from(document.querySelectorAll(".e-columnmenu, .e-contextmenu"))));
+        /** @type {?} */
+        var visibleContainers = menuContainers.filter((/**
+         * @param {?} container
+         * @return {?}
+         */
+        function (container) {
+            if (!container || !container.getBoundingClientRect) {
+                return false;
+            }
+            /** @type {?} */
+            var rect = container.getBoundingClientRect();
+            if (rect.width <= 0 || rect.height <= 0) {
+                return false;
+            }
+            /** @type {?} */
+            var style = window.getComputedStyle(container);
+            if (!style || style.display === "none" || style.visibility === "hidden") {
+                return false;
+            }
+            return true;
+        }));
+        if (!visibleContainers.length) {
+            return null;
+        }
+        /** @type {?} */
+        var currentContainer = visibleContainers[visibleContainers.length - 1];
+        /** @type {?} */
+        var menuItems = (/** @type {?} */ (Array.from(currentContainer.querySelectorAll(".e-menu-item"))));
+        /** @type {?} */
+        var visibleFilterItems = menuItems.filter((/**
+         * @param {?} item
+         * @return {?}
+         */
+        function (item) {
+            if (!_this.isDateFilterMenuItem(item)) {
+                return false;
+            }
+            if (!item.getBoundingClientRect) {
+                return false;
+            }
+            /** @type {?} */
+            var rect = item.getBoundingClientRect();
+            return rect.width > 0 && rect.height > 0;
+        }));
+        if (!visibleFilterItems.length) {
+            return null;
+        }
+        /** @type {?} */
+        var focusedItem = visibleFilterItems.find((/**
+         * @param {?} item
+         * @return {?}
+         */
+        function (item) {
+            return (item.classList.contains("e-focused") ||
+                item.classList.contains("e-selected") ||
+                item.classList.contains("e-hover"));
+        }));
+        return focusedItem || visibleFilterItems[visibleFilterItems.length - 1];
+    };
+    return DateTreeFilterHelper;
+}());
+export { DateTreeFilterHelper };
+if (false) {
+    /** @type {?} */
+    DateTreeFilterHelper.prototype.popoverVisible;
+    /** @type {?} */
+    DateTreeFilterHelper.prototype.popoverField;
+    /** @type {?} */
+    DateTreeFilterHelper.prototype.popoverStyle;
+    /** @type {?} */
+    DateTreeFilterHelper.prototype.selectedByField;
+    /** @type {?} */
+    DateTreeFilterHelper.prototype.fieldLabelMap;
+    /** @type {?} */
+    DateTreeFilterHelper.prototype.dateFields;
+    /**
+     * @type {?}
+     * @private
+     */
+    DateTreeFilterHelper.prototype.sourceRows;
+    /**
+     * @type {?}
+     * @private
+     */
+    DateTreeFilterHelper.prototype.options;
+    /**
+     * @type {?}
+     * @private
+     */
+    DateTreeFilterHelper.prototype.defaultDateFormats;
+}
+/**
+ * @param {?} host
+ * @return {?}
+ */
+function resolveGridElement(host) {
+    if (!host || !host.grid) {
+        return null;
+    }
+    /** @type {?} */
+    var gridRef = host.grid;
+    if (gridRef.grid && gridRef.grid.element) {
+        return gridRef.grid.element;
+    }
+    if (gridRef.element) {
+        return gridRef.element;
+    }
+    return null;
+}
+/**
+ * @param {?} host
+ * @param {?} applyRows
+ * @param {?=} dateFormats
+ * @return {?}
+ */
+export function createRsCommonGridDateTreeHelper(host, applyRows, dateFormats) {
+    return new DateTreeFilterHelper({
+        getTranslation: (/**
+         * @return {?}
+         */
+        function () { return (host ? host.translation : null); }),
+        getPopoverElement: (/**
+         * @return {?}
+         */
+        function () {
+            return host && host.dateTreePopoverRef
+                ? host.dateTreePopoverRef.nativeElement
+                : null;
+        }),
+        getGridElement: (/**
+         * @return {?}
+         */
+        function () { return resolveGridElement(host); }),
+        applyRows: applyRows,
+        dateFormats: dateFormats && dateFormats.length
+            ? dateFormats
+            : DATE_TREE_DEFAULT_DATE_FORMATS,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-tree-filter.helper.js","sourceRoot":"ng://raise-common-lib/","sources":["lib/date-tree-filter/date-tree-filter.helper.ts"],"names":[],"mappings":"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","sourcesContent":["import moment from \"moment\";\r\n\r\nexport interface DateTreeFilterSetupOptions {\r\n  rows: any[];\r\n  fields: any[];\r\n  hints: string[];\r\n}\r\n\r\nexport interface DateTreeFilterHelperOptions {\r\n  getTranslation: () => any;\r\n  getPopoverElement: () => HTMLElement;\r\n  getGridElement: () => HTMLElement;\r\n  applyRows: (rows: any[]) => void;\r\n  parseDateValue?: (value: any) => Date;\r\n  dateFormats?: string[];\r\n}\r\n\r\nexport interface RsCommonGridDateTreeFactoryHost {\r\n  translation: any;\r\n  dateTreePopoverRef: any;\r\n  grid: any;\r\n}\r\n\r\nexport const DATE_TREE_DEFAULT_DATE_FORMATS = [\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];\r\n\r\nexport class DateTreeFilterHelper {\r\n  public popoverVisible = false;\r\n  public popoverField = \"\";\r\n  public popoverStyle = {};\r\n  public selectedByField = {};\r\n  public fieldLabelMap = {};\r\n  public dateFields = [];\r\n\r\n  private sourceRows = [];\r\n  private options: DateTreeFilterHelperOptions;\r\n  private defaultDateFormats = [\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    \"DD-MMM-YYYY hh:mm A\",\r\n    \"MMM DD, YYYY\",\r\n    moment.ISO_8601,\r\n  ];\r\n\r\n  constructor(options: DateTreeFilterHelperOptions) {\r\n    this.options = options;\r\n  }\r\n\r\n  public setup(config: DateTreeFilterSetupOptions) {\r\n    var rows = config && config.rows ? config.rows : [];\r\n    var fields = config && config.fields ? config.fields : [];\r\n    var hints = config && config.hints ? config.hints : [];\r\n    this.sourceRows = rows;\r\n    this.dateFields = this.resolveDateTreeFieldsByHints(fields, hints);\r\n    this.fieldLabelMap = {};\r\n    (fields || []).forEach((item) => {\r\n      if (!item || !item.columnName) {\r\n        return;\r\n      }\r\n      this.fieldLabelMap[item.columnName] =\r\n        item.columnDisplayName || item.columnName;\r\n    });\r\n    this.apply();\r\n  }\r\n\r\n  public handleGridActionBegin(args: any) {\r\n    var requestType = this.getRequestType(args);\r\n    if (\r\n      requestType === \"filterchoicerequest\" ||\r\n      requestType === \"filtersearchbegin\"\r\n    ) {\r\n      args.filterChoiceCount = 15000;\r\n    }\r\n    if (requestType !== \"filterbeforeopen\") {\r\n      return;\r\n    }\r\n    var columnName = this.resolveActionColumnName(args);\r\n    if (!this.isDateTreeField(columnName)) {\r\n      this.close();\r\n      return;\r\n    }\r\n    args.cancel = true;\r\n    this.open(columnName);\r\n  }\r\n\r\n  public updateSelection(selectionMap: any) {\r\n    this.selectedByField = selectionMap || {};\r\n    this.apply();\r\n  }\r\n\r\n  public close() {\r\n    if (!this.popoverVisible) {\r\n      return;\r\n    }\r\n    this.popoverVisible = false;\r\n    this.popoverField = \"\";\r\n    this.popoverStyle = {};\r\n  }\r\n\r\n  public handleDocumentMouseDown(event: MouseEvent) {\r\n    if (!this.popoverVisible) {\r\n      return;\r\n    }\r\n    var target = event.target as HTMLElement;\r\n    if (!target) {\r\n      return;\r\n    }\r\n    if (this.isInsidePopover(target) || this.isDateFilterMenuItem(target)) {\r\n      return;\r\n    }\r\n    this.close();\r\n  }\r\n\r\n  public handleDocumentMouseOver(event: MouseEvent) {\r\n    if (!this.popoverVisible) {\r\n      return;\r\n    }\r\n    var target = event.target as HTMLElement;\r\n    if (!target) {\r\n      return;\r\n    }\r\n    if (this.isInsidePopover(target)) {\r\n      return;\r\n    }\r\n    var menuItem = target.closest(\".e-menu-item\") as HTMLElement;\r\n    if (menuItem) {\r\n      if (!this.isDateFilterMenuItem(menuItem)) {\r\n        this.close();\r\n      }\r\n      return;\r\n    }\r\n    var otherFilterTarget = target.closest(\r\n      \".e-filtermenudiv, .e-headercell .e-columnmenu, .e-columnmenu, .e-contextmenu\"\r\n    ) as HTMLElement;\r\n    if (otherFilterTarget && !this.isDateFilterMenuItem(otherFilterTarget)) {\r\n      this.close();\r\n    }\r\n  }\r\n\r\n  public updatePosition() {\r\n    if (!this.popoverVisible) {\r\n      return;\r\n    }\r\n    var anchor = this.findDateFilterAnchorElement();\r\n    if (anchor) {\r\n      var rect = anchor.getBoundingClientRect();\r\n      var viewportWidth =\r\n        window.innerWidth || document.documentElement.clientWidth;\r\n      var viewportHeight =\r\n        window.innerHeight || document.documentElement.clientHeight;\r\n      var popoverElement = this.options.getPopoverElement\r\n        ? this.options.getPopoverElement()\r\n        : null;\r\n      var popoverWidth =\r\n        popoverElement && popoverElement.offsetWidth\r\n          ? popoverElement.offsetWidth\r\n          : 300;\r\n      var popoverHeight =\r\n        popoverElement && popoverElement.offsetHeight\r\n          ? popoverElement.offsetHeight\r\n          : 420;\r\n      var edgeGap = 8;\r\n      var anchorGap = 8;\r\n      var top = rect.top - 6;\r\n      var left = rect.right + anchorGap;\r\n\r\n      if (left + popoverWidth > viewportWidth - edgeGap) {\r\n        left = rect.left - popoverWidth - anchorGap;\r\n      }\r\n      if (left < edgeGap) {\r\n        left = edgeGap;\r\n      }\r\n      if (left + popoverWidth > viewportWidth - edgeGap) {\r\n        left = Math.max(edgeGap, viewportWidth - popoverWidth - edgeGap);\r\n      }\r\n      if (top + popoverHeight > viewportHeight - edgeGap) {\r\n        top = Math.max(edgeGap, viewportHeight - popoverHeight - edgeGap);\r\n      }\r\n      this.popoverStyle = {\r\n        position: \"fixed\",\r\n        left: left + \"px\",\r\n        top: top + \"px\",\r\n      };\r\n      return;\r\n    }\r\n    var gridElement = this.options.getGridElement\r\n      ? this.options.getGridElement()\r\n      : null;\r\n    if (gridElement && gridElement.getBoundingClientRect) {\r\n      var fallbackRect = gridElement.getBoundingClientRect();\r\n      this.popoverStyle = {\r\n        position: \"fixed\",\r\n        left: Math.max(8, fallbackRect.right - 312) + \"px\",\r\n        top: Math.max(8, fallbackRect.top + 8) + \"px\",\r\n      };\r\n    }\r\n  }\r\n\r\n  private open(field: string) {\r\n    this.popoverField = field;\r\n    this.popoverVisible = true;\r\n    this.updatePosition();\r\n    setTimeout(() => this.updatePosition(), 50);\r\n    setTimeout(() => this.updatePosition(), 150);\r\n  }\r\n\r\n  private apply() {\r\n    var filteredRows = this.filterRowsBySelectedDateTree(\r\n      this.sourceRows || []\r\n    );\r\n    this.options.applyRows(filteredRows);\r\n  }\r\n\r\n  private getRequestType(args) {\r\n    if (!args || !args.requestType) {\r\n      return \"\";\r\n    }\r\n    return String(args.requestType).trim().toLowerCase();\r\n  }\r\n\r\n  private resolveActionColumnName(args) {\r\n    if (!args) {\r\n      return \"\";\r\n    }\r\n    return (\r\n      args.columnName ||\r\n      args.field ||\r\n      args.currentFilteringColumn ||\r\n      (args.column && (args.column.field || args.column.columnName)) ||\r\n      \"\"\r\n    );\r\n  }\r\n\r\n  private resolveDateTreeFieldsByHints(fields: any[], hints: string[]) {\r\n    var normalizedHints = (hints || [])\r\n      .filter((item) => !!item)\r\n      .map((item) => String(item).trim().toLowerCase());\r\n    if (!fields || !fields.length || !normalizedHints.length) {\r\n      return [];\r\n    }\r\n    return fields\r\n      .filter((item) => {\r\n        if (!item || !item.columnName) {\r\n          return false;\r\n        }\r\n        var columnName = String(item.columnName || \"\").toLowerCase();\r\n        var displayName = String(item.columnDisplayName || \"\").toLowerCase();\r\n        return normalizedHints.some((hint) => {\r\n          return (\r\n            columnName === hint ||\r\n            displayName === hint ||\r\n            (hint.length >= 3 &&\r\n              (columnName.indexOf(hint) > -1 ||\r\n                displayName.indexOf(hint) > -1))\r\n          );\r\n        });\r\n      })\r\n      .map((item) => item.columnName);\r\n  }\r\n\r\n  private isDateTreeField(field: string) {\r\n    return this.dateFields.indexOf(field) > -1;\r\n  }\r\n\r\n  private getFieldDaySelectionMap(field: string) {\r\n    if (!this.selectedByField[field]) {\r\n      this.selectedByField[field] = {};\r\n    }\r\n    return this.selectedByField[field];\r\n  }\r\n\r\n  private filterRowsBySelectedDateTree(rows: any[], excludeField?: string) {\r\n    var filteredRows = rows ? rows.slice() : [];\r\n    this.dateFields.forEach((field) => {\r\n      if (excludeField && field === excludeField) {\r\n        return;\r\n      }\r\n      var selectedMap = this.getFieldDaySelectionMap(field);\r\n      var selectedKeys = Object.keys(selectedMap);\r\n      if (!selectedKeys.length) {\r\n        return;\r\n      }\r\n      filteredRows = filteredRows.filter((row) => {\r\n        var 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 getDayKeyByRowValue(value: any) {\r\n    var 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 parseDateValue(value: any): Date {\r\n    if (this.options.parseDateValue) {\r\n      return this.options.parseDateValue(value);\r\n    }\r\n    if (!value) {\r\n      return null;\r\n    }\r\n    if (value instanceof Date) {\r\n      return value;\r\n    }\r\n    var formats =\r\n      this.options && this.options.dateFormats && this.options.dateFormats.length\r\n        ? this.options.dateFormats\r\n        : this.defaultDateFormats;\r\n    var parsed = moment(value, formats, true);\r\n    if (parsed.isValid()) {\r\n      return parsed.toDate();\r\n    }\r\n    var fallback = new Date(value);\r\n    return isNaN(fallback.getTime()) ? null : fallback;\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 isInsidePopover(target: HTMLElement): boolean {\r\n    var popoverElement = this.options.getPopoverElement\r\n      ? this.options.getPopoverElement()\r\n      : null;\r\n    if (!target || !popoverElement) {\r\n      return false;\r\n    }\r\n    return popoverElement.contains(target);\r\n  }\r\n\r\n  private isDateFilterMenuItem(element: HTMLElement): boolean {\r\n    if (!element) {\r\n      return false;\r\n    }\r\n    var menuItem = element.closest(\".e-menu-item\") as HTMLElement;\r\n    if (!menuItem) {\r\n      return false;\r\n    }\r\n    var text = (menuItem.textContent || \"\").trim().toLowerCase();\r\n    var translation = this.options.getTranslation\r\n      ? this.options.getTranslation()\r\n      : null;\r\n    var filterText = String((translation && translation.FILTER) || \"filter\")\r\n      .trim()\r\n      .toLowerCase();\r\n    if (!text) {\r\n      return false;\r\n    }\r\n    if (text.indexOf(filterText) > -1 || text.indexOf(\"filter\") > -1) {\r\n      return true;\r\n    }\r\n    var cls = (menuItem.className || \"\").toLowerCase();\r\n    return cls.indexOf(\"filter\") > -1;\r\n  }\r\n\r\n  private findDateFilterAnchorElement(): HTMLElement {\r\n    var menuContainers = Array.from(\r\n      document.querySelectorAll(\".e-columnmenu, .e-contextmenu\")\r\n    ) as HTMLElement[];\r\n    var visibleContainers = menuContainers.filter((container) => {\r\n      if (!container || !container.getBoundingClientRect) {\r\n        return false;\r\n      }\r\n      var rect = container.getBoundingClientRect();\r\n      if (rect.width <= 0 || rect.height <= 0) {\r\n        return false;\r\n      }\r\n      var style = window.getComputedStyle(container);\r\n      if (!style || style.display === \"none\" || style.visibility === \"hidden\") {\r\n        return false;\r\n      }\r\n      return true;\r\n    });\r\n    if (!visibleContainers.length) {\r\n      return null;\r\n    }\r\n    var currentContainer = visibleContainers[visibleContainers.length - 1];\r\n    var menuItems = Array.from(\r\n      currentContainer.querySelectorAll(\".e-menu-item\")\r\n    ) as HTMLElement[];\r\n    var visibleFilterItems = menuItems.filter((item) => {\r\n      if (!this.isDateFilterMenuItem(item)) {\r\n        return false;\r\n      }\r\n      if (!item.getBoundingClientRect) {\r\n        return false;\r\n      }\r\n      var rect = item.getBoundingClientRect();\r\n      return rect.width > 0 && rect.height > 0;\r\n    });\r\n    if (!visibleFilterItems.length) {\r\n      return null;\r\n    }\r\n    var focusedItem = visibleFilterItems.find((item) => {\r\n      return (\r\n        item.classList.contains(\"e-focused\") ||\r\n        item.classList.contains(\"e-selected\") ||\r\n        item.classList.contains(\"e-hover\")\r\n      );\r\n    });\r\n    return focusedItem || visibleFilterItems[visibleFilterItems.length - 1];\r\n  }\r\n}\r\n\r\nfunction resolveGridElement(host: RsCommonGridDateTreeFactoryHost): HTMLElement {\r\n  if (!host || !host.grid) {\r\n    return null;\r\n  }\r\n  var gridRef = host.grid;\r\n  if (gridRef.grid && gridRef.grid.element) {\r\n    return gridRef.grid.element;\r\n  }\r\n  if (gridRef.element) {\r\n    return gridRef.element;\r\n  }\r\n  return null;\r\n}\r\n\r\nexport function createRsCommonGridDateTreeHelper(\r\n  host: RsCommonGridDateTreeFactoryHost,\r\n  applyRows: (rows: any[]) => void,\r\n  dateFormats?: string[]\r\n) {\r\n  return new DateTreeFilterHelper({\r\n    getTranslation: () => (host ? host.translation : null),\r\n    getPopoverElement: () =>\r\n      host && host.dateTreePopoverRef\r\n        ? host.dateTreePopoverRef.nativeElement\r\n        : null,\r\n    getGridElement: () => resolveGridElement(host),\r\n    applyRows: applyRows,\r\n    dateFormats:\r\n      dateFormats && dateFormats.length\r\n        ? dateFormats\r\n        : DATE_TREE_DEFAULT_DATE_FORMATS,\r\n  });\r\n}\r\n"]}