@genesislcap/grid-pro 15.21.1 → 15.22.1

package/dist/esm/column-filters/enum-column.filter.js

@@ -0,0 +1,525 @@
+import { css } from '@microsoft/fast-element';
+import { capitalCase } from 'change-case';
+import { logger } from '../utils';
+/**
+ * The available Grid Pro column filter component names.
+ * @remarks Register-able via the grid `components` map; `enumFilter` is usable as a
+ * `ColDef.filter` value and `enumFloatingFilter` as a `ColDef.floatingFilterComponent`.
+ * @public
+ */
+export var GridProFilterTypes;
+(function (GridProFilterTypes) {
+    GridProFilterTypes["enumFilter"] = "enumColumnFilter";
+    GridProFilterTypes["enumFloatingFilter"] = "enumColumnFloatingFilter";
+})(GridProFilterTypes || (GridProFilterTypes = {}));
+const BLANKS_LABEL = '(Blanks)';
+/**
+ * Builds the value-to-label formatter for an enum filter, honouring `valueFormatter` from the
+ * filter params and labelling `null` (blanks) consistently.
+ * @remarks Shared by {@link EnumColumnFilter} and the floating filter so both render the same
+ * labels from `ColDef.filterParams` alone.
+ * @public
+ */
+export function createEnumValueLabelFormatter(params) {
+    const userFormatter = params === null || params === void 0 ? void 0 : params.valueFormatter;
+    const format = userFormatter
+        ? (value) => String(userFormatter({
+            value,
+            api: params === null || params === void 0 ? void 0 : params.api,
+            colDef: params === null || params === void 0 ? void 0 : params.colDef,
+            column: params === null || params === void 0 ? void 0 : params.column,
+            context: params === null || params === void 0 ? void 0 : params.context,
+        }))
+        : (value) => capitalCase(value);
+    return (value) => (value === null ? BLANKS_LABEL : format(value));
+}
+/**
+ * Renders an enum filter model as a short summary, e.g. `(2) Active, Pending`.
+ * @public
+ */
+export function formatEnumFilterModelAsString(model, formatLabel) {
+    if (!(model === null || model === void 0 ? void 0 : model.values)) {
+        return '';
+    }
+    if (model.values.length === 0) {
+        return '(None)';
+    }
+    return `(${model.values.length}) ${model.values.map(formatLabel).join(', ')}`;
+}
+const CSS_PREFIX = 'gp-enum-filter';
+/**
+ * Applied to each instance's shadow root; FAST shares one constructable stylesheet between them.
+ */
+const filterStyles = css `
+  :host {
+    display: flex;
+    flex-direction: column;
+    gap: 4px;
+    padding: 6px;
+    min-width: 180px;
+    color: var(--ag-foreground-color, inherit);
+    background: var(--ag-control-panel-background-color, transparent);
+    font: inherit;
+  }
+  .${CSS_PREFIX}__search {
+    box-sizing: border-box;
+    width: 100%;
+    padding: 4px 6px;
+    font: inherit;
+    color: inherit;
+    background: var(--ag-background-color, transparent);
+    border: 1px solid var(--ag-input-border-color, var(--ag-border-color, #babfc7));
+    border-radius: 3px;
+    outline: none;
+  }
+  .${CSS_PREFIX}__search:focus {
+    border-color: var(
+      --ag-input-focus-border-color,
+      var(--ag-range-selection-border-color, #2196f3)
+    );
+  }
+  .${CSS_PREFIX}__select-all {
+    border-bottom: 1px solid var(--ag-border-color, #babfc7);
+    padding-bottom: 4px;
+  }
+  .${CSS_PREFIX}__list {
+    max-height: 210px;
+    overflow-y: auto;
+    display: flex;
+    flex-direction: column;
+  }
+  .${CSS_PREFIX}__item {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    padding: 3px 4px;
+    cursor: pointer;
+    border-radius: 3px;
+    user-select: none;
+  }
+  .${CSS_PREFIX}__item:hover, .${CSS_PREFIX}__item:focus-within {
+    background: var(--ag-row-hover-color, rgba(33, 150, 243, 0.1));
+  }
+  .${CSS_PREFIX}__item input {
+    margin: 0;
+    accent-color: var(--ag-checkbox-checked-color, var(--ag-range-selection-border-color, #2196f3));
+  }
+  .${CSS_PREFIX}__item-label {
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+  .${CSS_PREFIX}__no-matches {
+    padding: 4px;
+    opacity: 0.7;
+  }
+`;
+/**
+ * An Excel AutoFilter-inspired set filter for enum columns, built on AG Grid Community only.
+ * @remarks
+ * Renders a searchable checkbox list of the column's enum options (from `filterParams.values`,
+ * fed by the resource field metadata or a values getter — the option list is defined by the enum,
+ * never scanned from row data) with a tri-state "(Select All)" toggle scoped to the search
+ * results, a `(Blanks)` entry shown by default, human-readable labels, and arrow-key navigation —
+ * applying on every change. Emits the same `{ filterType: 'set', values }` model as the
+ * enterprise `agSetColumnFilter`, so it is a drop-in replacement for filter-model persistence and
+ * the Genesis server-side criteria building — without requiring the enterprise `SetFilterModule`.
+ * @public
+ */
+export class EnumColumnFilter {
+    constructor() {
+        /** Rendered value checkboxes keyed by value; `null` keys the blanks entry. */
+        this.itemInputs = new Map();
+        /** All selectable values, in the order the metadata/getter provided them. */
+        this.allValues = [];
+        /** Whether the `(Blanks)` entry is offered — on unless `filterParams.blanks` is `false`. */
+        this.includeBlanks = true;
+        /** Guards async values resolution against out-of-date responses and use after destroy. */
+        this.valuesRequestId = 0;
+        this.loading = false;
+        /** Whether this instance installed the header tooltip getter (so destroy removes only its own). */
+        this.ownsHeaderTooltip = false;
+        /**
+         * `null` while inactive (everything passes); otherwise the selected values, with `null`
+         * standing for blanks. May contain values absent from `allValues` (e.g. a restored model
+         * referencing rows not loaded yet) — those are preserved and rendered as extra list entries
+         * so restoring a persisted model never silently narrows it, while still letting the user
+         * deselect them.
+         */
+        this.model = null;
+        this.searchTerm = '';
+    }
+    init(params) {
+        this.params = params;
+        this.formatLabel = createEnumValueLabelFormatter(params);
+        this.installHeaderTooltip();
+        this.createGui();
+        this.resolveState();
+    }
+    getGui() {
+        return this.eGui;
+    }
+    isFilterActive() {
+        return this.model !== null;
+    }
+    doesFilterPass(params) {
+        if (this.model === null) {
+            return true;
+        }
+        const value = this.getCellValue(params.node);
+        if (value === null || value === undefined || value === '') {
+            return this.model.includes(null);
+        }
+        return this.model.includes(String(value));
+    }
+    getModel() {
+        if (this.model === null) {
+            return null;
+        }
+        return { filterType: 'set', values: [...this.model] };
+    }
+    setModel(model) {
+        this.model = (model === null || model === void 0 ? void 0 : model.values) ? [...model.values] : null;
+        this.syncCheckedStates();
+    }
+    getModelAsString(model) {
+        return formatEnumFilterModelAsString(model !== null && model !== void 0 ? model : this.getModel(), this.formatLabel);
+    }
+    /** Clears the filter back to inactive and notifies the grid; used by the floating filter. */
+    clear() {
+        if (this.model === null) {
+            return;
+        }
+        this.model = null;
+        this.syncCheckedStates();
+        this.params.filterChangedCallback();
+    }
+    /**
+     * Surfaces the active selection in the column's header tooltip (alongside AG's native header
+     * filter icon), so the filter state is inspectable from the header without the layout-changing
+     * floating filter row. Installed as a `headerTooltipValueGetter`, which AG evaluates lazily on
+     * hover — no header refresh needed when the model changes. While inactive it returns
+     * `undefined`, which falls back to the consumer's own `headerTooltip`; when active, that
+     * tooltip is kept as the prefix. A consumer-provided getter is left untouched.
+     */
+    installHeaderTooltip() {
+        const colDef = this.params.colDef;
+        if (!colDef || colDef.headerTooltipValueGetter) {
+            return;
+        }
+        this.ownsHeaderTooltip = true;
+        colDef.headerTooltipValueGetter = () => {
+            const summary = formatEnumFilterModelAsString(this.getModel(), this.formatLabel);
+            if (!summary) {
+                return undefined;
+            }
+            return colDef.headerTooltip
+                ? `${colDef.headerTooltip} — Filtered: ${summary}`
+                : `Filtered: ${summary}`;
+        };
+    }
+    afterGuiAttached(params) {
+        this.searchTerm = '';
+        this.eSearch.value = '';
+        this.renderList();
+        if (!(params === null || params === void 0 ? void 0 : params.suppressFocus)) {
+            this.eSearch.focus();
+        }
+    }
+    refresh(params) {
+        this.params = params;
+        this.formatLabel = createEnumValueLabelFormatter(params);
+        // A refresh can carry a brand-new colDef object without the tooltip getter.
+        this.installHeaderTooltip();
+        this.resolveState();
+        return true;
+    }
+    destroy() {
+        var _a;
+        this.valuesRequestId += 1;
+        // Remove the tooltip getter this instance installed (never a consumer's): its closure holds
+        // the instance, and a successor filter created for the same colDef object would otherwise
+        // early-return in installHeaderTooltip and leave the header reporting the dead instance's
+        // frozen model.
+        if (this.ownsHeaderTooltip) {
+            delete this.params.colDef
+                .headerTooltipValueGetter;
+            this.ownsHeaderTooltip = false;
+        }
+        (_a = this.eGui) === null || _a === void 0 ? void 0 : _a.remove();
+    }
+    /** Resolves the option list (values array or getter) and re-renders. */
+    resolveState() {
+        var _a;
+        // Bound the loading flag's lifetime to this resolution attempt: a refresh() can supersede a
+        // pending async getter with synchronous values, and the superseded apply() never runs.
+        this.loading = false;
+        this.includeBlanks = this.params.blanks !== false;
+        const provided = this.params.values;
+        if (typeof provided === 'function') {
+            this.loadAsyncValues(provided);
+            return;
+        }
+        if (Array.isArray(provided)) {
+            this.allValues = [...new Set(provided.map(String))];
+        }
+        else {
+            // An enum's option list is defined by its metadata, never derived from row data — a filter
+            // without values can only offer the blanks entry.
+            logger.warn(`EnumColumnFilter on column '${(_a = this.params.colDef) === null || _a === void 0 ? void 0 : _a.field}' has no ` +
+                'filterParams.values; provide the enum options (metadata enumOptions, an array, or a getter).');
+            this.allValues = [];
+        }
+        this.renderList();
+    }
+    loadAsyncValues(getValues) {
+        this.valuesRequestId += 1;
+        const requestId = this.valuesRequestId;
+        let applied = false;
+        const apply = (values) => {
+            if (applied || requestId !== this.valuesRequestId) {
+                return;
+            }
+            applied = true;
+            this.loading = false;
+            this.allValues = [...new Set((values !== null && values !== void 0 ? values : []).map(String))];
+            this.renderList();
+        };
+        let result;
+        try {
+            result = getValues({ colDef: this.params.colDef, api: this.params.api, success: apply });
+        }
+        catch (_a) {
+            apply([]);
+            return;
+        }
+        if (applied) {
+            // The getter resolved synchronously through `success`.
+            return;
+        }
+        if (Array.isArray(result)) {
+            apply(result);
+            return;
+        }
+        if (result !== undefined) {
+            const thenable = result;
+            // A getter typed away from the contract can return neither an array, a thenable, nor
+            // undefined at runtime — treat that as no values rather than crashing on `.then`.
+            if (typeof thenable.then !== 'function') {
+                apply([]);
+                return;
+            }
+            this.loading = true;
+            this.renderList();
+            thenable.then(apply, () => apply([]));
+            return;
+        }
+        // No return value: AG set-filter style — wait for the `success` callback.
+        this.loading = true;
+        this.renderList();
+    }
+    /** The raw field read covers params without `getValue` (e.g. stripped-down test params). */
+    getCellValue(node) {
+        var _a, _b;
+        const params = this.params;
+        if (typeof params.getValue === 'function') {
+            return params.getValue(node);
+        }
+        const field = (_a = params.colDef) === null || _a === void 0 ? void 0 : _a.field;
+        return field ? (_b = node === null || node === void 0 ? void 0 : node.data) === null || _b === void 0 ? void 0 : _b[field] : undefined;
+    }
+    /** Model values that are not in the option list, e.g. from a restored persisted model. */
+    extraModelValues() {
+        var _a;
+        return ((_a = this.model) !== null && _a !== void 0 ? _a : []).filter((value) => value !== null && !this.allValues.includes(value));
+    }
+    /**
+     * All offered entry keys: the option list, then any off-list model values (rendered so they can
+     * be deselected rather than being stuck in the model forever), then `null` (blanks) last like
+     * Excel. The blanks entry is also offered whenever the model references it, so a restored
+     * blanks selection stays visible and removable even before blank rows are detected.
+     */
+    allKeys() {
+        var _a;
+        const keys = [...this.allValues, ...this.extraModelValues()];
+        if (this.includeBlanks || ((_a = this.model) === null || _a === void 0 ? void 0 : _a.includes(null))) {
+            keys.push(null);
+        }
+        return keys;
+    }
+    isSelected(key) {
+        return this.model === null || this.model.includes(key);
+    }
+    visibleKeys() {
+        const keys = this.allKeys();
+        if (!this.searchTerm) {
+            return keys;
+        }
+        const term = this.searchTerm.toLowerCase();
+        return keys.filter((key) => this.formatLabel(key).toLowerCase().includes(term) ||
+            (key !== null && key.toLowerCase().includes(term)));
+    }
+    /**
+     * Applies a new selection. Collapses back to the inactive (`null`) model when every offered
+     * entry is selected, so a fully re-selected filter reports inactive exactly like the
+     * enterprise set filter. Selected values beyond the offered keys don't restrict anything an
+     * inactive filter would pass, so a superset selection collapses too.
+     */
+    updateSelection(selected) {
+        const isAll = this.allKeys().every((key) => selected.has(key));
+        this.model = isAll ? null : [...selected];
+        this.syncCheckedStates();
+        this.params.filterChangedCallback();
+    }
+    currentSelection() {
+        return new Set(this.allKeys().filter((key) => this.isSelected(key)));
+    }
+    toggleValue(key, checked) {
+        const selected = this.currentSelection();
+        if (checked) {
+            selected.add(key);
+        }
+        else {
+            selected.delete(key);
+        }
+        this.updateSelection(selected);
+    }
+    /** Select-all acts on the searched subset only, mirroring Excel's AutoFilter. */
+    toggleAllVisible(checked) {
+        const visible = this.visibleKeys();
+        const selected = this.currentSelection();
+        visible.forEach((key) => (checked ? selected.add(key) : selected.delete(key)));
+        this.updateSelection(selected);
+    }
+    createGui() {
+        this.eGui = document.createElement('div');
+        this.eGui.className = CSS_PREFIX;
+        // Content lives in a shadow root so the FAST stylesheet travels with the element wherever
+        // AG attaches it — one adopted stylesheet shared across instances, nothing injected into
+        // foreign roots. Keydown is listened to inside the root, where targets are not retargeted.
+        this.eRoot = this.eGui.attachShadow({ mode: 'open' });
+        filterStyles.addStylesTo(this.eRoot);
+        this.eRoot.addEventListener('keydown', (event) => this.handleKeyDown(event));
+        this.eSearch = document.createElement('input');
+        this.eSearch.type = 'text';
+        this.eSearch.className = `${CSS_PREFIX}__search`;
+        this.eSearch.placeholder = 'Search';
+        this.eSearch.setAttribute('aria-label', 'Search filter values');
+        this.eSearch.addEventListener('input', () => {
+            this.searchTerm = this.eSearch.value.trim();
+            this.renderList();
+        });
+        this.eRoot.appendChild(this.eSearch);
+        const selectAllItem = this.createItem('(Select All)');
+        selectAllItem.label.classList.add(`${CSS_PREFIX}__select-all`);
+        this.eSelectAll = selectAllItem.input;
+        this.eSelectAll.addEventListener('change', () => {
+            this.toggleAllVisible(this.eSelectAll.checked);
+        });
+        this.eRoot.appendChild(selectAllItem.label);
+        this.eList = document.createElement('div');
+        this.eList.className = `${CSS_PREFIX}__list`;
+        this.eRoot.appendChild(this.eList);
+    }
+    createItem(text) {
+        const label = document.createElement('label');
+        label.className = `${CSS_PREFIX}__item`;
+        const input = document.createElement('input');
+        input.type = 'checkbox';
+        label.appendChild(input);
+        const span = document.createElement('span');
+        span.className = `${CSS_PREFIX}__item-label`;
+        span.textContent = text;
+        span.title = text;
+        label.appendChild(span);
+        return { label, input };
+    }
+    /** Rebuilds the value list; used when the values or the search term change. */
+    renderList() {
+        if (!this.eList) {
+            return;
+        }
+        this.eList.replaceChildren();
+        this.itemInputs.clear();
+        const visible = this.visibleKeys();
+        if (this.loading || visible.length === 0) {
+            const empty = document.createElement('div');
+            empty.className = `${CSS_PREFIX}__no-matches`;
+            empty.textContent = this.loading ? 'Loading…' : 'No matches';
+            this.eList.appendChild(empty);
+        }
+        if (!this.loading) {
+            visible.forEach((key) => {
+                const { label, input } = this.createItem(this.formatLabel(key));
+                label.dataset.value = key === null ? '' : key;
+                input.addEventListener('change', () => this.toggleValue(key, input.checked));
+                this.itemInputs.set(key, input);
+                this.eList.appendChild(label);
+            });
+        }
+        this.syncCheckedStates();
+    }
+    /** Refreshes checkbox states in place, preserving DOM (and keyboard focus) on toggles. */
+    syncCheckedStates() {
+        if (!this.eList) {
+            return;
+        }
+        let selectedCount = 0;
+        this.itemInputs.forEach((input, key) => {
+            input.checked = this.isSelected(key);
+            if (input.checked) {
+                selectedCount += 1;
+            }
+        });
+        const visibleCount = this.itemInputs.size;
+        this.eSelectAll.checked = visibleCount > 0 && selectedCount === visibleCount;
+        this.eSelectAll.indeterminate = selectedCount > 0 && selectedCount < visibleCount;
+        this.eSelectAll.disabled = visibleCount === 0;
+    }
+    focusables() {
+        return [this.eSearch, this.eSelectAll, ...this.itemInputs.values()];
+    }
+    /**
+     * Arrow keys walk search box, "(Select All)" and the visible entries; Enter toggles the
+     * focused entry (Space is the checkbox's native toggle). Tab wraps within the popup: AG's own
+     * popup focus trap collects focusable elements with `querySelectorAll`, which does not pierce
+     * the shadow root, so the trap must live here.
+     */
+    handleKeyDown(event) {
+        const target = event.target;
+        if (event.key === 'Enter' && target instanceof HTMLInputElement && target.type === 'checkbox') {
+            event.preventDefault();
+            target.checked = !target.checked;
+            target.dispatchEvent(new Event('change'));
+            return;
+        }
+        if (event.key === 'Tab') {
+            const focusables = this.focusables();
+            const first = focusables[0];
+            const last = focusables[focusables.length - 1];
+            if (event.shiftKey && target === first) {
+                event.preventDefault();
+                last.focus();
+            }
+            else if (!event.shiftKey && target === last) {
+                event.preventDefault();
+                first.focus();
+            }
+            return;
+        }
+        if (event.key !== 'ArrowDown' && event.key !== 'ArrowUp') {
+            return;
+        }
+        const focusables = this.focusables();
+        const currentIndex = focusables.indexOf(target);
+        if (currentIndex === -1) {
+            return;
+        }
+        const nextIndex = event.key === 'ArrowDown' ? currentIndex + 1 : currentIndex - 1;
+        if (nextIndex < 0 || nextIndex >= focusables.length) {
+            return;
+        }
+        event.preventDefault();
+        focusables[nextIndex].focus();
+    }
+}

package/dist/esm/column-filters/enum-column.floating-filter.js

@@ -0,0 +1,109 @@
+import { css } from '@microsoft/fast-element';
+import { createEnumValueLabelFormatter, formatEnumFilterModelAsString, } from './enum-column.filter';
+const INACTIVE_SUMMARY = 'All';
+const CSS_PREFIX = 'gp-enum-floating-filter';
+/**
+ * Applied to each instance's shadow root; FAST shares one constructable stylesheet between them.
+ */
+const floatingFilterStyles = css `
+  :host {
+    display: flex;
+    align-items: center;
+    gap: 4px;
+    width: 100%;
+    min-width: 0;
+    color: var(--ag-foreground-color, inherit);
+    font: inherit;
+  }
+  .${CSS_PREFIX}__summary {
+    flex: 1;
+    min-width: 0;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    cursor: pointer;
+    opacity: 0.85;
+  }
+  .${CSS_PREFIX}__summary--inactive {
+    opacity: 0.5;
+  }
+  .${CSS_PREFIX}__clear {
+    flex: none;
+    border: none;
+    background: none;
+    color: inherit;
+    font: inherit;
+    line-height: 1;
+    padding: 2px 4px;
+    cursor: pointer;
+    border-radius: 3px;
+    opacity: 0.7;
+  }
+  .${CSS_PREFIX}__clear:hover {
+    opacity: 1;
+    background: var(--ag-row-hover-color, rgba(33, 150, 243, 0.1));
+  }
+`;
+/**
+ * Floating filter companion for {@link EnumColumnFilter}: shows the current selection as a
+ * compact summary (e.g. `(2) Active, Pending`), opens the parent filter on click, and offers a
+ * one-click clear. Set via `ColDef.floatingFilterComponent` (see
+ * {@link GridProFilterTypes.enumFloatingFilter}); shown when the column enables `floatingFilter`.
+ * @public
+ */
+export class EnumColumnFloatingFilter {
+    init(params) {
+        var _a, _b;
+        this.params = params;
+        this.formatLabel = createEnumValueLabelFormatter(params.filterParams);
+        this.eGui = document.createElement('div');
+        this.eGui.className = CSS_PREFIX;
+        // Content lives in a shadow root so the FAST stylesheet travels with the element wherever AG
+        // attaches it — floating filters get no attach hook, so styles cannot be injected on attach.
+        this.eRoot = this.eGui.attachShadow({ mode: 'open' });
+        floatingFilterStyles.addStylesTo(this.eRoot);
+        this.eSummary = document.createElement('span');
+        this.eSummary.className = `${CSS_PREFIX}__summary`;
+        this.eSummary.setAttribute('role', 'button');
+        this.eSummary.tabIndex = 0;
+        this.eSummary.addEventListener('click', () => this.params.showParentFilter());
+        this.eSummary.addEventListener('keydown', (event) => {
+            if (event.key === 'Enter' || event.key === ' ') {
+                event.preventDefault();
+                this.params.showParentFilter();
+            }
+        });
+        this.eRoot.appendChild(this.eSummary);
+        this.eClear = document.createElement('button');
+        this.eClear.type = 'button';
+        this.eClear.className = `${CSS_PREFIX}__clear`;
+        this.eClear.textContent = '✕';
+        this.eClear.setAttribute('aria-label', 'Clear filter');
+        this.eClear.title = 'Clear filter';
+        this.eClear.hidden = true;
+        this.eClear.addEventListener('click', () => {
+            this.params.parentFilterInstance((instance) => {
+                var _a, _b;
+                (_b = (_a = instance).clear) === null || _b === void 0 ? void 0 : _b.call(_a);
+            });
+        });
+        this.eRoot.appendChild(this.eClear);
+        this.onParentModelChanged(((_b = (_a = params.currentParentModel) === null || _a === void 0 ? void 0 : _a.call(params)) !== null && _b !== void 0 ? _b : null));
+    }
+    getGui() {
+        return this.eGui;
+    }
+    onParentModelChanged(model) {
+        // Real text rather than CSS-generated content, so the inactive state is not silent for
+        // screen readers.
+        const summary = formatEnumFilterModelAsString(model, this.formatLabel) || INACTIVE_SUMMARY;
+        this.eSummary.textContent = summary;
+        this.eSummary.title = summary;
+        this.eSummary.classList.toggle(`${CSS_PREFIX}__summary--inactive`, !model);
+        this.eClear.hidden = !model;
+    }
+    destroy() {
+        var _a;
+        (_a = this.eGui) === null || _a === void 0 ? void 0 : _a.remove();
+    }
+}

package/dist/esm/column-filters/index.js

@@ -0,0 +1,2 @@
+export * from './enum-column.filter';
+export * from './enum-column.floating-filter';