@revolist/revogrid 4.9.13 → 4.9.16

package/dist/esm/{column.drag.plugin-30dc4e24.js → column.drag.plugin-18125693.js}

@@ -1,13 +1,13 @@
 /*!
  * Built by Revolist OU ❤️
  */
-import { V as createStore, W as reduce_1, v as setStore, h as calculateDimensionData, X as isArray_1, Y as each, b as getSourceItem, n as getScrollbarSize, Z as toInteger_1, _ as _isIterateeCall, q as timeout, i as getItemByPosition } from './index-74b9801b.js';
-import { f as calculateRowHeaderSize } from './row-header-utils-c7e3e2d5.js';
+import { V as createStore, W as reduce_1, v as setStore, h as calculateDimensionData, X as each, b as getSourceItem, n as getScrollbarSize, Y as toInteger_1, _ as _isIterateeCall, q as timeout, i as getItemByPosition } from './index-00cb6ac1.js';
+import { e as getColumnType, m as isGrouping, o as getGroupingName, d as getCellDataParsed, h as isColGrouping } from './column.service-00a51837.js';
+import { f as calculateRowHeaderSize } from './row-header-utils-30750b8e.js';
 import { d as debounce_1 } from './debounce-e8e9464a.js';
 import { h } from './index-a61f225b.js';
-import { b as isGrouping, d as getGroupingName } from './column.service-414e9cba.js';
 import { F as FILTER_PROP, i as isFilterBtn } from './filter.button-37373672.js';
-import { d as dispatch, O as ON_COLUMN_CLICK } from './header-cell-renderer-ca570fcf.js';
+import { d as dispatch, O as ON_COLUMN_CLICK } from './header-cell-renderer-6d89f141.js';
 
 /**
  * Storing pre-calculated
@@ -213,125 +213,6 @@ class BasePlugin {
     }
 }
 
-function getColumnType(rgCol) {
-    if (rgCol.pin) {
-        return rgCol.pin;
-    }
-    return 'rgCol';
-}
-function getColumnSizes(cols) {
-    const res = {};
-    for (const [i, c] of cols.entries()) {
-        if (c.size) {
-            res[i] = c.size;
-        }
-    }
-    return res;
-}
-/**
- * Check if column is grouping column
- */
-function isColGrouping(colData) {
-    return !!colData.children;
-}
-/**
- * This function is used to create a collection of columns.
- */
-function getColumns(columns, level = 0, types) {
-    const collection = {
-        // columns as they are in stores per type
-        columns: {
-            rgCol: [],
-            colPinStart: [],
-            colPinEnd: [],
-        },
-        // columns indexed by prop for quick access
-        columnByProp: {},
-        // column grouping
-        columnGrouping: {
-            rgCol: [],
-            colPinStart: [],
-            colPinEnd: [],
-        },
-        // max depth level for column grouping
-        maxLevel: level,
-        // sorting
-        sort: {},
-    };
-    return reduce_1(columns, (res, colData) => {
-        // Grouped column
-        if (isColGrouping(colData)) {
-            return gatherGroup(res, colData, getColumns(colData.children, level + 1, types), level);
-        }
-        // Regular column
-        const regularColumn = Object.assign(Object.assign({}, (colData.columnType && types && types[colData.columnType])), colData);
-        // Regular column, no Pin
-        if (!regularColumn.pin) {
-            res.columns.rgCol.push(regularColumn);
-            // Pin
-        }
-        else {
-            res.columns[regularColumn.pin].push(regularColumn);
-        }
-        if (regularColumn.order) {
-            res.sort[regularColumn.prop] = regularColumn;
-        }
-        // it's possible that some columns have same prop, but better to avoid it
-        if (!res.columnByProp[regularColumn.prop]) {
-            res.columnByProp[regularColumn.prop] = [];
-        }
-        res.columnByProp[regularColumn.prop].push(regularColumn);
-        // trigger setup hook if present
-        regularColumn.beforeSetup && regularColumn.beforeSetup(regularColumn);
-        return res;
-    }, collection);
-}
-function gatherGroup(res, colData, collection, level = 0) {
-    // group template
-    const group = Object.assign(Object.assign({}, colData), { level, ids: [] });
-    // check columns for update
-    for (let k in collection.columns) {
-        const key = k;
-        const resultItem = res.columns[key];
-        const collectionItem = collection.columns[key];
-        // if column data
-        if (isArray_1(resultItem) && isArray_1(collectionItem)) {
-            // fill columns
-            resultItem.push(...collectionItem);
-            // fill grouping
-            if (collectionItem.length) {
-                res.columnGrouping[key].push(Object.assign(Object.assign({}, group), { ids: collectionItem.map(item => item.prop) }));
-            }
-        }
-    }
-    // merge column groupings
-    for (let k in collection.columnGrouping) {
-        const key = k;
-        const collectionItem = collection.columnGrouping[key];
-        res.columnGrouping[key].push(...collectionItem);
-    }
-    res.maxLevel = Math.max(res.maxLevel, collection.maxLevel);
-    res.sort = Object.assign(Object.assign({}, res.sort), collection.sort);
-    return res;
-}
-function findColumn(columns, prop) {
-    for (const c of columns) {
-        if (isColGrouping(c)) {
-            const found = findColumn(c.children, prop);
-            if (found) {
-                return found;
-            }
-        }
-        else if (c.prop === prop) {
-            return c;
-        }
-    }
-    return undefined;
-}
-function getColumnByProp(columns, prop) {
-    return findColumn(columns, prop);
-}
-
 /**
  * Plugin module for revo-grid grid system
  * Add support for automatic column resize
@@ -1110,23 +991,7 @@ const notContains = (value, extra) => {
 notContains.extra = 'input';
 contains.extra = 'input';
 
-const filterNames = {
-    none: 'None',
-    empty: 'Not set',
-    notEmpty: 'Set',
-    eq: 'Equal',
-    notEq: 'Not equal',
-    begins: 'Begins with',
-    contains: 'Contains',
-    notContains: 'Does not contain',
-    eqN: '=',
-    neqN: '!=',
-    gt: '>',
-    gte: '>=',
-    lt: '<',
-    lte: '<=',
-};
-const filterEntities = {
+const filterCoreFunctionsIndexedByType = {
     none: () => true,
     empty: notSet,
     notEmpty: set,
@@ -1146,7 +1011,37 @@ const filterTypes = {
     string: ['notEmpty', 'empty', 'eq', 'notEq', 'begins', 'contains', 'notContains'],
     number: ['notEmpty', 'empty', 'eqN', 'neqN', 'gt', 'gte', 'lt', 'lte'],
 };
+const filterNames = {
+    none: 'None',
+    empty: 'Not set',
+    notEmpty: 'Set',
+    eq: 'Equal',
+    notEq: 'Not equal',
+    begins: 'Begins with',
+    contains: 'Contains',
+    notContains: 'Does not contain',
+    eqN: '=',
+    neqN: '!=',
+    gt: '>',
+    gte: '>=',
+    lt: '<',
+    lte: '<=',
+};
 
+/**
+ * @typedef ColumnFilterConfig
+ * @type {object}
+ * @property {FilterCollection|undefined} collection - preserved filter data
+ * @property {string[]|undefined} include - filters to be included, if defined everything else out of scope will be ignored
+ * @property {Record<string, CustomFilter>|undefined} customFilters - hash map of {FilterType:CustomFilter}.
+ * @property {FilterLocalization|undefined} localization - translation for filter popup captions.
+ * @property {MultiFilterItem|undefined} multiFilterItems - data for multi filtering.
+ * @property {boolean|undefined} disableDynamicFiltering - disables dynamic filtering.
+ * A way to define your own filter types per column
+ */
+/**
+ * @internal
+ */
 const FILTER_TRIMMED_TYPE = 'filter';
 const FILTER_CONFIG_CHANGED_EVENT = 'filterconfigchanged';
 class FilterPlugin extends BasePlugin {
@@ -1156,14 +1051,13 @@ class FilterPlugin extends BasePlugin {
         this.revogrid = revogrid;
         this.filterCollection = {};
         this.multiFilterItems = {};
-        this.possibleFilters = Object.assign({}, filterTypes);
-        this.possibleFilterNames = Object.assign({}, filterNames);
-        this.possibleFilterEntities = Object.assign({}, filterEntities);
+        this.filterByType = Object.assign({}, filterTypes);
+        this.filterNameIndexByType = Object.assign({}, filterNames);
+        this.filterFunctionsIndexedByType = Object.assign({}, filterCoreFunctionsIndexedByType);
         this.filterProp = FILTER_PROP;
         if (config) {
             this.initConfig(config);
         }
-        const headerclick = (e) => this.headerclick(e);
         const aftersourceset = async () => {
             const filterCollectionProps = Object.keys(this.filterCollection);
             if (filterCollectionProps.length > 0) {
@@ -1183,7 +1077,7 @@ class FilterPlugin extends BasePlugin {
             }
             await this.runFiltering();
         };
-        this.addEventListener('headerclick', headerclick);
+        this.addEventListener('headerclick', (e) => this.headerclick(e));
         this.addEventListener(FILTER_CONFIG_CHANGED_EVENT, ({ detail }) => {
             if (!detail) {
                 this.clearFiltering();
@@ -1196,27 +1090,29 @@ class FilterPlugin extends BasePlugin {
         });
         this.addEventListener('aftersourceset', aftersourceset);
         this.addEventListener('filter', ({ detail }) => this.onFilterChange(detail));
-        const existingNodes = this.revogrid.registerVNode.filter((n) => n.$tag$ !== 'revogr-filter-panel');
+        const existingNodes = this.revogrid.registerVNode.filter(n => n.$tag$ !== 'revogr-filter-panel');
         this.revogrid.registerVNode = [
             ...existingNodes,
-            h("revogr-filter-panel", { filterItems: this.multiFilterItems, filterNames: this.possibleFilterNames, filterEntities: this.possibleFilterEntities, filterCaptions: (_a = config === null || config === void 0 ? void 0 : config.localization) === null || _a === void 0 ? void 0 : _a.captions, onFilterChange: e => this.onFilterChange(e.detail), disableDynamicFiltering: config === null || config === void 0 ? void 0 : config.disableDynamicFiltering, ref: e => (this.pop = e) }),
+            h("revogr-filter-panel", { filterItems: this.multiFilterItems, filterNames: this.filterNameIndexByType, filterEntities: this.filterFunctionsIndexedByType, filterCaptions: (_a = config === null || config === void 0 ? void 0 : config.localization) === null || _a === void 0 ? void 0 : _a.captions, onFilterChange: e => this.onFilterChange(e.detail), disableDynamicFiltering: config === null || config === void 0 ? void 0 : config.disableDynamicFiltering, ref: e => (this.pop = e) }),
         ];
     }
     initConfig(config) {
         if (config.multiFilterItems) {
             this.multiFilterItems = Object.assign({}, config.multiFilterItems);
         }
+        // Add custom filters
         if (config.customFilters) {
-            for (let cType in config.customFilters) {
-                const cFilter = config.customFilters[cType];
-                if (!this.possibleFilters[cFilter.columnFilterType]) {
-                    this.possibleFilters[cFilter.columnFilterType] = [];
+            for (let customFilterType in config.customFilters) {
+                const cFilter = config.customFilters[customFilterType];
+                if (!this.filterByType[cFilter.columnFilterType]) {
+                    this.filterByType[cFilter.columnFilterType] = [];
                 }
-                this.possibleFilters[cFilter.columnFilterType].push(cType);
-                this.possibleFilterEntities[cType] = cFilter.func;
-                this.possibleFilterNames[cType] = cFilter.name;
+                this.filterByType[cFilter.columnFilterType].push(customFilterType);
+                this.filterFunctionsIndexedByType[customFilterType] = cFilter.func;
+                this.filterNameIndexByType[customFilterType] = cFilter.name;
             }
         }
+        // Add filterProp if provided in config
         if (config.filterProp) {
             this.filterProp = config.filterProp;
         }
@@ -1227,21 +1123,21 @@ class FilterPlugin extends BasePlugin {
         const cfgInlcude = config.include;
         if (cfgInlcude) {
             const filters = {};
-            for (let t in this.possibleFilters) {
+            for (let t in this.filterByType) {
                 // validate filters, if appropriate function present
-                const newTypes = this.possibleFilters[t].filter(f => cfgInlcude.indexOf(f) > -1);
+                const newTypes = this.filterByType[t].filter(f => cfgInlcude.indexOf(f) > -1);
                 if (newTypes.length) {
                     filters[t] = newTypes;
                 }
             }
             // if any valid filters provided show them
             if (Object.keys(filters).length > 0) {
-                this.possibleFilters = filters;
+                this.filterByType = filters;
             }
         }
         if (config.collection) {
             this.filterCollection = reduce_1(config.collection, (result, item, prop) => {
-                if (this.possibleFilterEntities[item.type]) {
+                if (this.filterFunctionsIndexedByType[item.type]) {
                     result[prop] = item;
                 }
                 else {
@@ -1253,8 +1149,8 @@ class FilterPlugin extends BasePlugin {
         if (config.localization) {
             if (config.localization.filterNames) {
                 Object.entries(config.localization.filterNames).forEach(([k, v]) => {
-                    if (this.possibleFilterNames[k] != void 0) {
-                        this.possibleFilterNames[k] = v;
+                    if (this.filterNameIndexByType[k] != void 0) {
+                        this.filterNameIndexByType[k] = v;
                     }
                 });
             }
@@ -1280,13 +1176,12 @@ class FilterPlugin extends BasePlugin {
         const gridPos = this.revogrid.getBoundingClientRect();
         const buttonPos = el.getBoundingClientRect();
         const prop = e.detail.prop;
-        this.pop.filterTypes = this.getColumnFilter(e.detail.filter);
-        this.pop.show(Object.assign(Object.assign({}, this.filterCollection[prop]), { x: buttonPos.x - gridPos.x, y: buttonPos.y - gridPos.y + buttonPos.height, autoCorrect: true, prop }));
+        this.pop.show(Object.assign(Object.assign({}, this.filterCollection[prop]), { x: buttonPos.x - gridPos.x, y: buttonPos.y - gridPos.y + buttonPos.height, autoCorrect: true, prop, filterTypes: this.getColumnFilter(e.detail.filter) }));
     }
     getColumnFilter(type) {
         let filterType = 'string';
         if (!type) {
-            return { [filterType]: this.possibleFilters[filterType] };
+            return { [filterType]: this.filterByType[filterType] };
         }
         // if custom column filter
         if (this.isValidType(type)) {
@@ -1296,44 +1191,59 @@ class FilterPlugin extends BasePlugin {
         else if (typeof type === 'object' && type.length) {
             return type.reduce((r, multiType) => {
                 if (this.isValidType(multiType)) {
-                    r[multiType] = this.possibleFilters[multiType];
+                    r[multiType] = this.filterByType[multiType];
                 }
                 return r;
             }, {});
         }
-        return { [filterType]: this.possibleFilters[filterType] };
+        return { [filterType]: this.filterByType[filterType] };
     }
     isValidType(type) {
-        return !!(typeof type === 'string' && this.possibleFilters[type]);
+        return !!(typeof type === 'string' && this.filterByType[type]);
     }
-    // called on internal component change
+    /**
+     * Called on internal component change
+     */
     async onFilterChange(filterItems) {
+        // store the filter items
         this.multiFilterItems = filterItems;
+        // run the filtering when the items change
         this.runFiltering();
     }
     /**
      * Triggers grid filtering
      */
-    async doFiltering(collection, items, columns, filterItems) {
+    async doFiltering(collection, source, columns, filterItems) {
         const columnsToUpdate = [];
+        /**
+         * Loop through the columns and update the columns that need to be updated with the `hasFilter` property.
+         */
+        const columnByProp = {};
         columns.forEach(rgCol => {
             const column = Object.assign({}, rgCol);
             const hasFilter = filterItems[column.prop];
+            columnByProp[column.prop] = column;
+            /**
+             * If the column has a filter and it's not already marked as filtered, update the column.
+             */
             if (column[this.filterProp] && !hasFilter) {
                 delete column[this.filterProp];
                 columnsToUpdate.push(column);
             }
+            /**
+             * If the column does not have a filter and it's marked as filtered, update the column.
+             */
             if (!column[this.filterProp] && hasFilter) {
                 columnsToUpdate.push(column);
                 column[this.filterProp] = true;
             }
         });
-        const itemsToFilter = this.getRowFilter(items, filterItems);
+        const itemsToTrim = this.getRowFilter(source, filterItems, columnByProp);
         // check is filter event prevented
         const { defaultPrevented, detail } = this.emit('beforefiltertrimmed', {
             collection,
-            itemsToFilter,
-            source: items,
+            itemsToFilter: itemsToTrim,
+            source,
             filterItems,
         });
         if (defaultPrevented) {
@@ -1345,7 +1255,7 @@ class FilterPlugin extends BasePlugin {
             return;
         }
         // applies the hasFilter to the columns to show filter icon
-        await this.revogrid.updateColumns(columnsToUpdate);
+        this.providers.column.updateColumns(columnsToUpdate);
         this.emit('afterfilterapply');
     }
     async clearFiltering() {
@@ -1361,7 +1271,7 @@ class FilterPlugin extends BasePlugin {
             if (this.multiFilterItems[prop].length > 0) {
                 const firstFilterItem = this.multiFilterItems[prop][0];
                 collection[prop] = {
-                    filter: filterEntities[firstFilterItem.type],
+                    filter: this.filterFunctionsIndexedByType[firstFilterItem.type],
                     type: firstFilterItem.type,
                     value: firstFilterItem.value,
                 };
@@ -1386,52 +1296,68 @@ class FilterPlugin extends BasePlugin {
             columns: await this.revogrid.getColumns(),
         };
     }
-    getRowFilter(rows, filterItems) {
+    /**
+     * Get trimmed rows based on filter
+     */
+    getRowFilter(rows, filterItems, columnByProp) {
         const propKeys = Object.keys(filterItems);
         const trimmed = {};
         let propFilterSatisfiedCount = 0;
         let lastFilterResults = [];
         // each rows
         rows.forEach((model, rowIndex) => {
-            // working on all props
+            // check filter by column properties
             for (const prop of propKeys) {
                 const propFilters = filterItems[prop];
+                // reset the count of satisfied filters
                 propFilterSatisfiedCount = 0;
+                // reset the array of last filter results
                 lastFilterResults = [];
                 // testing each filter for a prop
                 for (const [filterIndex, filterData] of propFilters.entries()) {
                     // the filter LogicFunction based on the type
-                    const filter = this.possibleFilterEntities[filterData.type];
+                    const filterFunc = this.filterFunctionsIndexedByType[filterData.type];
                     // THE MAGIC OF FILTERING IS HERE
+                    const column = columnByProp[prop];
+                    // If there is no column but user wants to filter by a property
+                    const value = column ? getCellDataParsed(model, columnByProp[prop]) : model[prop];
+                    // OR relation
                     if (filterData.relation === 'or') {
+                        // reset the array of last filter results
                         lastFilterResults = [];
-                        if (filter(model[prop], filterData.value)) {
+                        // if the filter is satisfied, continue to the next filter
+                        if (filterFunc(value, filterData.value)) {
                             continue;
                         }
+                        // if the filter is not satisfied, count it
                         propFilterSatisfiedCount++;
+                        // AND relation
                     }
                     else {
                         // 'and' relation will need to know the next filter
                         // so we save this current filter to include it in the next filter
-                        lastFilterResults.push(!filter(model[prop], filterData.value));
+                        lastFilterResults.push(!filterFunc(value, filterData.value));
                         // check first if we have a filter on the next index to pair it with this current filter
                         const nextFilterData = propFilters[filterIndex + 1];
                         // stop the sequence if there is no next filter or if the next filter is not an 'and' relation
                         if (!nextFilterData || nextFilterData.relation !== 'and') {
                             // let's just continue since for sure propFilterSatisfiedCount cannot be satisfied
                             if (lastFilterResults.indexOf(true) === -1) {
+                                // reset the array of last filter results
                                 lastFilterResults = [];
                                 continue;
                             }
                             // we need to add all of the lastFilterResults since we need to satisfy all
                             propFilterSatisfiedCount += lastFilterResults.length;
+                            // reset the array of last filter results
                             lastFilterResults = [];
                         }
                     }
                 } // end of propFilters forEach
                 // add to the list of removed/trimmed rows of filter condition is satisfied
-                if (propFilterSatisfiedCount === propFilters.length)
+                if (propFilterSatisfiedCount === propFilters.length) {
                     trimmed[rowIndex] = true;
+                }
             } // end of for-of propKeys
         });
         return trimmed;
@@ -1660,6 +1586,6 @@ function getLeftRelative(absoluteX, gridPos, offset) {
     return absoluteX - gridPos - offset;
 }
 
-export { AutoSizeColumnPlugin as A, BasePlugin as B, ColumnPlugin as C, DimensionStore as D, ExportFilePlugin as E, FILTER_TRIMMED_TYPE as F, StretchColumn as S, isStretchPlugin as a, FILTER_CONFIG_CHANGED_EVENT as b, columnTypes as c, FilterPlugin as d, getColumnType as e, getColumnSizes as f, getLeftRelative as g, isColGrouping as h, isRowType as i, getColumns as j, gatherGroup as k, getColumnByProp as l, rowTypes as r };
+export { AutoSizeColumnPlugin as A, BasePlugin as B, ColumnPlugin as C, DimensionStore as D, ExportFilePlugin as E, FILTER_TRIMMED_TYPE as F, StretchColumn as S, isStretchPlugin as a, FILTER_CONFIG_CHANGED_EVENT as b, columnTypes as c, FilterPlugin as d, getLeftRelative as g, isRowType as i, rowTypes as r };
 
-//# sourceMappingURL=column.drag.plugin-30dc4e24.js.map
+//# sourceMappingURL=column.drag.plugin-18125693.js.map