@ozen-ui/data-grid 0.73.0

package/__inner__/cjs/core/filter/store/base/types.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataGridStoreFilterEvent = exports.dataGridStoreFilterValueType = void 0;
+exports.dataGridStoreFilterValueType = [
+    'default',
+    'local',
+    'allFilter',
+];
+exports.dataGridStoreFilterEvent = {
+    CHANGE_VALUE: 'changeValue',
+    CHANGE_LOCAL_VALUE: 'changeLocalValue',
+    CHANGE_ALL_FILTER_VALUE: 'changeAllFilterValue',
+};

package/__inner__/cjs/core/filter/store/date/DataGridStoreDateFilter.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataGridStoreDateFilter = void 0;
+var tslib_1 = require("tslib");
+var utils_1 = require("@ozen-ui/kit/utils");
+var lodash_clonedeep_1 = tslib_1.__importDefault(require("lodash.clonedeep"));
+var lodash_isequal_1 = tslib_1.__importDefault(require("lodash.isequal"));
+var mobx_1 = require("mobx");
+var base_1 = require("../base");
+var utils_2 = require("./utils");
+var DataGridStoreDateFilter = /** @class */ (function (_super) {
+    tslib_1.__extends(DataGridStoreDateFilter, _super);
+    function DataGridStoreDateFilter(filter, context) {
+        var _this = _super.call(this, filter, context) || this;
+        _this.value = null;
+        _this.localValue = null;
+        _this.allFilterValue = null;
+        _this.min = filter.min;
+        _this.max = filter.max;
+        _this.type = filter.type;
+        var rawRender = filter.render;
+        _this.render = rawRender
+            ? function (_a) {
+                var type = _a.type;
+                return (0, utils_1.renderContent)({
+                    content: rawRender,
+                    props: { filter: _this, context: _this.context, type: type },
+                });
+            }
+            : null;
+        (0, mobx_1.makeObservable)(_this, {
+            min: mobx_1.observable,
+            max: mobx_1.observable,
+            type: mobx_1.observable,
+            value: mobx_1.observable,
+            localValue: mobx_1.observable,
+            allFilterValue: mobx_1.observable,
+            setMin: mobx_1.action,
+            setMax: mobx_1.action,
+            setType: mobx_1.action,
+            isActive: mobx_1.computed,
+            render: mobx_1.observable,
+        });
+        return _this;
+    }
+    Object.defineProperty(DataGridStoreDateFilter.prototype, "isActive", {
+        get: function () {
+            if ((0, utils_2.isDateFilterRangeValue)(this.value)) {
+                return !!this.value.from || !!this.value.to;
+            }
+            return this.value !== null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DataGridStoreDateFilter.prototype.processValue = function (value) {
+        if ((0, utils_2.isDateFilterSingleValue)(value)) {
+            return value;
+        }
+        if (!(value === null || value === void 0 ? void 0 : value.from) && !(value === null || value === void 0 ? void 0 : value.to)) {
+            return null;
+        }
+        return value;
+    };
+    DataGridStoreDateFilter.prototype.isEqualValues = function (value1, value2) {
+        var processedValue1 = this.processValue(value1);
+        var processedValue2 = this.processValue(value2);
+        return (0, lodash_isequal_1.default)((0, mobx_1.toJS)(processedValue1), (0, mobx_1.toJS)(processedValue2));
+    };
+    DataGridStoreDateFilter.prototype.setValue = function (value) {
+        _super.prototype.setValue.call(this, this.processValue(value));
+    };
+    DataGridStoreDateFilter.prototype.setLocalValue = function (value) {
+        _super.prototype.setLocalValue.call(this, this.processValue(value));
+    };
+    DataGridStoreDateFilter.prototype.setAllFilterValue = function (value) {
+        _super.prototype.setAllFilterValue.call(this, this.processValue(value));
+    };
+    DataGridStoreDateFilter.prototype.reset = function () {
+        this.setValue(null);
+    };
+    DataGridStoreDateFilter.prototype.setMin = function (min) {
+        var oldMin = (0, lodash_clonedeep_1.default)(this.min);
+        this.min = min;
+        if (!(0, lodash_isequal_1.default)(oldMin, min)) {
+            this.eventBus.publish('changeMin', min);
+        }
+    };
+    DataGridStoreDateFilter.prototype.setMax = function (max) {
+        var oldMax = (0, lodash_clonedeep_1.default)(this.max);
+        this.max = max;
+        if (!(0, lodash_isequal_1.default)(oldMax, max)) {
+            this.eventBus.publish('changeMax', max);
+        }
+    };
+    DataGridStoreDateFilter.prototype.setType = function (type) {
+        var _a;
+        var oldType = this.type;
+        this.type = type;
+        if (this.type === 'single' && (0, utils_2.isDateFilterRangeValue)(this.value)) {
+            this.setValue((_a = this.value.from) !== null && _a !== void 0 ? _a : null);
+        }
+        else if (this.type === 'range' && (0, utils_2.isDateFilterSingleValue)(this.value)) {
+            this.setValue({
+                from: this.value,
+                to: null,
+            });
+        }
+        if (oldType !== type) {
+            this.eventBus.publish('changeType', type);
+        }
+    };
+    return DataGridStoreDateFilter;
+}(base_1.DataGridStoreFilter));
+exports.DataGridStoreDateFilter = DataGridStoreDateFilter;

package/__inner__/cjs/core/filter/store/date/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./DataGridStoreDateFilter"), exports);
+tslib_1.__exportStar(require("./types"), exports);
+tslib_1.__exportStar(require("./utils"), exports);

package/__inner__/cjs/core/filter/store/date/types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataGridStoreDateFilterEvent = void 0;
+var tslib_1 = require("tslib");
+var base_1 = require("../base");
+exports.dataGridStoreDateFilterEvent = tslib_1.__assign(tslib_1.__assign({}, base_1.dataGridStoreFilterEvent), { CHANGE_TYPE: 'changeType', CHANGE_MIN: 'changeMin', CHANGE_MAX: 'changeMax' });

package/__inner__/cjs/core/filter/store/date/utils.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDateFilterSingleValue = exports.isDateFilterRangeValue = void 0;
+var tslib_1 = require("tslib");
+var utils_1 = require("@ozen-ui/kit/utils");
+var lodash_isdate_1 = tslib_1.__importDefault(require("lodash.isdate"));
+var isDateFilterRangeValue = function (value) {
+    return (0, utils_1.isPlainObject)(value) && 'from' && value && 'to' in value;
+};
+exports.isDateFilterRangeValue = isDateFilterRangeValue;
+var isDateFilterSingleValue = function (value) { return (0, lodash_isdate_1.default)(value); };
+exports.isDateFilterSingleValue = isDateFilterSingleValue;

package/__inner__/cjs/core/filter/store/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./autocomplete"), exports);
+tslib_1.__exportStar(require("./autocompleteListCard"), exports);
+tslib_1.__exportStar(require("./base"), exports);
+tslib_1.__exportStar(require("./date"), exports);
+tslib_1.__exportStar(require("./inputs"), exports);
+tslib_1.__exportStar(require("./select"), exports);
+tslib_1.__exportStar(require("./DataGridStoreFilters"), exports);
+tslib_1.__exportStar(require("./types"), exports);

package/__inner__/cjs/core/filter/store/inputs/DataGridStoreNumberFilter.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataGridStoreNumberFilter = void 0;
+var tslib_1 = require("tslib");
+var base_1 = require("./base");
+var DataGridStoreNumberFilter = /** @class */ (function (_super) {
+    tslib_1.__extends(DataGridStoreNumberFilter, _super);
+    function DataGridStoreNumberFilter() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    DataGridStoreNumberFilter.prototype.resetValue = function () {
+        this.setValue(null);
+    };
+    return DataGridStoreNumberFilter;
+}(base_1.DataGridStoreInputFilter));
+exports.DataGridStoreNumberFilter = DataGridStoreNumberFilter;

package/__inner__/cjs/core/filter/store/inputs/DataGridStoreStringFilter.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataGridStoreStringFilter = void 0;
+var tslib_1 = require("tslib");
+var base_1 = require("./base");
+var DataGridStoreStringFilter = /** @class */ (function (_super) {
+    tslib_1.__extends(DataGridStoreStringFilter, _super);
+    function DataGridStoreStringFilter() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    DataGridStoreStringFilter.prototype.resetValue = function () {
+        this.setValue(null);
+    };
+    return DataGridStoreStringFilter;
+}(base_1.DataGridStoreInputFilter));
+exports.DataGridStoreStringFilter = DataGridStoreStringFilter;

package/__inner__/cjs/core/filter/store/inputs/base/DataGridStoreInputFilter.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataGridStoreInputFilter = void 0;
+var tslib_1 = require("tslib");
+var utils_1 = require("@ozen-ui/kit/utils");
+var mobx_1 = require("mobx");
+var base_1 = require("../../base");
+var DataGridStoreInputFilter = /** @class */ (function (_super) {
+    tslib_1.__extends(DataGridStoreInputFilter, _super);
+    function DataGridStoreInputFilter(filter, context) {
+        var _this = _super.call(this, filter, context) || this;
+        _this.value = null;
+        _this.localValue = null;
+        _this.allFilterValue = null;
+        _this.render = null;
+        _this.isValid = true;
+        _this.isValidLocal = true;
+        _this.isValidAllFilter = true;
+        _this.rawValidate = filter.validate;
+        var rawRender = filter.render;
+        _this.render = rawRender
+            ? function (_a) {
+                var type = _a.type;
+                return (0, utils_1.renderContent)({
+                    content: rawRender,
+                    props: { filter: _this, context: _this.context, type: type },
+                });
+            }
+            : null;
+        (0, mobx_1.makeObservable)(_this, {
+            value: mobx_1.observable,
+            localValue: mobx_1.observable,
+            allFilterValue: mobx_1.observable,
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-expect-error
+            rawValidate: mobx_1.observable,
+            render: mobx_1.observable,
+            isValid: mobx_1.observable,
+            isValidLocal: mobx_1.observable,
+            isValidAllFilter: mobx_1.observable,
+            reset: mobx_1.action,
+            setIsValid: mobx_1.action,
+            setIsValidLocal: mobx_1.action,
+            setIsValidAllFilter: mobx_1.action,
+            setIsValidByType: mobx_1.action,
+            isActive: mobx_1.computed,
+        });
+        return _this;
+    }
+    DataGridStoreInputFilter.prototype.register = function () {
+        var _this = this;
+        _super.prototype.register.call(this);
+        var validate = function (context, type) {
+            var _a, _b;
+            var isValid = (_b = (_a = _this.rawValidate) === null || _a === void 0 ? void 0 : _a.call(_this, (0, mobx_1.untracked)(function () { return _this.valueByType(type); }), type, context)) !== null && _b !== void 0 ? _b : true;
+            (0, mobx_1.runInAction)(function () {
+                _this.setIsValidByType(isValid, type);
+            });
+        };
+        (0, mobx_1.autorun)(function () {
+            validate(_this.context, 'default');
+        });
+        (0, mobx_1.autorun)(function () {
+            validate(_this.context, 'local');
+        });
+        (0, mobx_1.autorun)(function () {
+            validate(_this.context, 'allFilter');
+        });
+    };
+    DataGridStoreInputFilter.prototype.validate = function (value, type) {
+        if (!this.rawValidate) {
+            return;
+        }
+        var currentValue = this.valueByType(type);
+        if (currentValue === value) {
+            return;
+        }
+        var isValid = this.rawValidate(value, type, this.context);
+        this.setIsValidByType(isValid, type);
+    };
+    DataGridStoreInputFilter.prototype.setValue = function (value) {
+        this.validate(value, 'default');
+        _super.prototype.setValue.call(this, value);
+    };
+    DataGridStoreInputFilter.prototype.setLocalValue = function (value) {
+        this.validate(value, 'local');
+        _super.prototype.setLocalValue.call(this, value);
+    };
+    DataGridStoreInputFilter.prototype.setAllFilterValue = function (value) {
+        this.validate(value, 'allFilter');
+        _super.prototype.setAllFilterValue.call(this, value);
+    };
+    DataGridStoreInputFilter.prototype.setIsValid = function (isValid) {
+        var previousIsValid = this.isValid;
+        this.isValid = isValid;
+        if (previousIsValid !== isValid) {
+            this.eventBus.publish('changeIsValid', {
+                isValid: isValid,
+                value: this.value,
+                type: 'default',
+            });
+        }
+    };
+    DataGridStoreInputFilter.prototype.setIsValidLocal = function (isValid) {
+        var previousIsValid = this.isValidLocal;
+        this.isValidLocal = isValid;
+        if (previousIsValid !== isValid) {
+            this.eventBus.publish('changeIsValid', {
+                isValid: isValid,
+                value: this.localValue,
+                type: 'local',
+            });
+        }
+    };
+    DataGridStoreInputFilter.prototype.setIsValidAllFilter = function (isValid) {
+        var previousIsValid = this.isValidAllFilter;
+        this.isValidAllFilter = isValid;
+        if (previousIsValid !== isValid) {
+            this.eventBus.publish('changeIsValid', {
+                isValid: isValid,
+                value: this.allFilterValue,
+                type: 'allFilter',
+            });
+        }
+    };
+    DataGridStoreInputFilter.prototype.setIsValidByType = function (isValid, type) {
+        switch (type) {
+            case 'default':
+                this.setIsValid(isValid);
+                break;
+            case 'local':
+                this.setIsValidLocal(isValid);
+                break;
+            case 'allFilter':
+                this.setIsValidAllFilter(isValid);
+                break;
+            default:
+                throw new Error("Incorrect value type \"".concat(type, "\". Expected: [").concat(base_1.dataGridStoreFilterValueType.join(', '), "]"));
+        }
+    };
+    DataGridStoreInputFilter.prototype.isValidByType = function (type) {
+        switch (type) {
+            case 'default':
+                return this.isValid;
+            case 'local':
+                return this.isValidLocal;
+            case 'allFilter':
+                return this.isValidAllFilter;
+            default:
+                throw new Error("Incorrect value type \"".concat(type, "\". Expected: [").concat(base_1.dataGridStoreFilterValueType.join(', '), "]"));
+        }
+    };
+    Object.defineProperty(DataGridStoreInputFilter.prototype, "isActive", {
+        get: function () {
+            return !!this.value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DataGridStoreInputFilter.prototype.isEqualValues = function (value1, value2) {
+        return value1 === value2;
+    };
+    DataGridStoreInputFilter.prototype.reset = function () {
+        this.resetValue();
+    };
+    return DataGridStoreInputFilter;
+}(base_1.DataGridStoreFilter));
+exports.DataGridStoreInputFilter = DataGridStoreInputFilter;

package/__inner__/cjs/core/filter/store/inputs/base/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./DataGridStoreInputFilter"), exports);
+tslib_1.__exportStar(require("./types"), exports);

package/__inner__/cjs/core/filter/store/inputs/base/types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataGridStoreInputFilterEvent = void 0;
+var tslib_1 = require("tslib");
+var base_1 = require("../../base");
+exports.dataGridStoreInputFilterEvent = tslib_1.__assign(tslib_1.__assign({}, base_1.dataGridStoreFilterEvent), { CHANGE_IS_VALID: 'changeIsValid' });

package/__inner__/cjs/core/filter/store/inputs/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./base"), exports);
+tslib_1.__exportStar(require("./DataGridStoreNumberFilter"), exports);
+tslib_1.__exportStar(require("./DataGridStoreStringFilter"), exports);

package/__inner__/cjs/core/filter/store/select/DataGridStoreBaseSelectFilter.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataGridStoreBaseSelectFilter = void 0;
+var tslib_1 = require("tslib");
+var utils_1 = require("@ozen-ui/kit/utils");
+var lodash_isequal_1 = tslib_1.__importDefault(require("lodash.isequal"));
+var mobx_1 = require("mobx");
+var base_1 = require("../base");
+var DataGridStoreBaseSelectFilter = /** @class */ (function (_super) {
+    tslib_1.__extends(DataGridStoreBaseSelectFilter, _super);
+    function DataGridStoreBaseSelectFilter(filter, context) {
+        var _this = _super.call(this, filter, context) || this;
+        _this.value = new Set();
+        _this.localValue = new Set();
+        _this.allFilterValue = new Set();
+        (0, mobx_1.makeObservable)(_this, {
+            value: mobx_1.observable,
+            localValue: mobx_1.observable,
+            allFilterValue: mobx_1.observable,
+            reset: mobx_1.action,
+            unselectOption: mobx_1.action,
+            selectOption: mobx_1.action,
+            setOptions: mobx_1.action,
+            addOption: mobx_1.action,
+            setType: mobx_1.action,
+            isActive: mobx_1.computed,
+            isSingle: mobx_1.computed,
+            isMultiple: mobx_1.computed,
+            optionById: mobx_1.computed,
+        });
+        return _this;
+    }
+    Object.defineProperty(DataGridStoreBaseSelectFilter.prototype, "isActive", {
+        get: function () {
+            var e_1, _a;
+            if (this.value.size === 0) {
+                return false;
+            }
+            var values = tslib_1.__spreadArray([], tslib_1.__read(this.value.values()), false);
+            try {
+                for (var values_1 = tslib_1.__values(values), values_1_1 = values_1.next(); !values_1_1.done; values_1_1 = values_1.next()) {
+                    var selected = values_1_1.value;
+                    if (this.optionById[selected]) {
+                        return true;
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (values_1_1 && !values_1_1.done && (_a = values_1.return)) _a.call(values_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return false;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DataGridStoreBaseSelectFilter.prototype.isEqualValues = function (value1, value2) {
+        return (0, lodash_isequal_1.default)((0, mobx_1.toJS)(value1), (0, mobx_1.toJS)(value2));
+    };
+    Object.defineProperty(DataGridStoreBaseSelectFilter.prototype, "isSingle", {
+        get: function () {
+            return this.type === 'single';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreBaseSelectFilter.prototype, "isMultiple", {
+        get: function () {
+            return this.type === 'multiple';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreBaseSelectFilter.prototype, "optionById", {
+        get: function () {
+            var optionById = {};
+            this.options.forEach(function (option) {
+                optionById[option.value] = option;
+            });
+            return optionById;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DataGridStoreBaseSelectFilter.prototype.reset = function () {
+        this.setValue(new Set());
+    };
+    DataGridStoreBaseSelectFilter.prototype.unselectOption = function (key) {
+        this.value.delete(key);
+        this.eventBus.publish('changeValue', this.value);
+    };
+    DataGridStoreBaseSelectFilter.prototype.selectOption = function (key) {
+        this.value.add(key);
+        this.eventBus.publish('changeValue', this.value);
+    };
+    DataGridStoreBaseSelectFilter.prototype.setOptions = function (options) {
+        var oldValue = this.options;
+        this.options = options;
+        if (!(0, utils_1.shallowEqual)(oldValue, options)) {
+            this.eventBus.publish('changeOptions', options);
+        }
+    };
+    DataGridStoreBaseSelectFilter.prototype.addOption = function (option) {
+        this.setOptions(tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(this.options), false), [option], false));
+    };
+    DataGridStoreBaseSelectFilter.prototype.setType = function (type) {
+        var _a;
+        var oldType = this.type;
+        this.type = type;
+        if (this.type === 'single' && this.value.size > 1) {
+            var firstValue = (_a = tslib_1.__spreadArray([], tslib_1.__read(this.value.values()), false)[0]) !== null && _a !== void 0 ? _a : null;
+            if (firstValue === null) {
+                return;
+            }
+            this.setValue(new Set([firstValue]));
+        }
+        if (oldType !== type) {
+            this.eventBus.publish('changeType', type);
+        }
+    };
+    return DataGridStoreBaseSelectFilter;
+}(base_1.DataGridStoreFilter));
+exports.DataGridStoreBaseSelectFilter = DataGridStoreBaseSelectFilter;

package/__inner__/cjs/core/filter/store/select/DataGridStoreSelectFilter.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataGridStoreSelectFilter = void 0;
+var tslib_1 = require("tslib");
+var utils_1 = require("@ozen-ui/kit/utils");
+var mobx_1 = require("mobx");
+var DataGridStoreBaseSelectFilter_1 = require("./DataGridStoreBaseSelectFilter");
+var DataGridStoreSelectFilter = /** @class */ (function (_super) {
+    tslib_1.__extends(DataGridStoreSelectFilter, _super);
+    function DataGridStoreSelectFilter(filter, context) {
+        var _this = _super.call(this, filter, context) || this;
+        _this.options = filter.options;
+        _this.type = filter.type;
+        var rawRender = filter.render;
+        _this.render = rawRender
+            ? function (_a) {
+                var type = _a.type;
+                return (0, utils_1.renderContent)({
+                    content: rawRender,
+                    props: { filter: _this, context: _this.context, type: type },
+                });
+            }
+            : null;
+        (0, mobx_1.makeObservable)(_this, {
+            options: mobx_1.observable,
+            type: mobx_1.observable,
+            render: mobx_1.observable,
+        });
+        return _this;
+    }
+    return DataGridStoreSelectFilter;
+}(DataGridStoreBaseSelectFilter_1.DataGridStoreBaseSelectFilter));
+exports.DataGridStoreSelectFilter = DataGridStoreSelectFilter;

package/__inner__/cjs/core/filter/store/select/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./DataGridStoreBaseSelectFilter"), exports);
+tslib_1.__exportStar(require("./DataGridStoreSelectFilter"), exports);
+tslib_1.__exportStar(require("./types"), exports);

package/__inner__/cjs/core/filter/store/select/types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataGridStoreSelectFilterEvent = void 0;
+var tslib_1 = require("tslib");
+var base_1 = require("../base");
+exports.dataGridStoreSelectFilterEvent = tslib_1.__assign(tslib_1.__assign({}, base_1.dataGridStoreFilterEvent), { CHANGE_TYPE: 'changeType', CHANGE_OPTIONS: 'changeOptions' });

package/__inner__/cjs/core/filter/store/types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataGridStoreFiltersEvent = void 0;
+exports.dataGridStoreFiltersEvent = {
+    CHANGE_FILTER: 'changeFilter',
+};

package/__inner__/cjs/core/filter/table/autocomplete/DataGridAutocompleteTableFilter.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataGridAutocompleteTableFilter = void 0;
+var tslib_1 = require("tslib");
+var base_1 = require("../base");
+var DataGridAutocompleteTableFilter = /** @class */ (function (_super) {
+    tslib_1.__extends(DataGridAutocompleteTableFilter, _super);
+    function DataGridAutocompleteTableFilter(_a) {
+        var _this = this;
+        var options = _a.options, type = _a.type, other = tslib_1.__rest(_a, ["options", "type"]);
+        _this = _super.call(this, tslib_1.__assign({}, other)) || this;
+        _this.options = options !== null && options !== void 0 ? options : [];
+        _this.type = type !== null && type !== void 0 ? type : 'multiple';
+        return _this;
+    }
+    return DataGridAutocompleteTableFilter;
+}(base_1.DataGridTableFilter));
+exports.DataGridAutocompleteTableFilter = DataGridAutocompleteTableFilter;

package/__inner__/cjs/core/filter/table/autocomplete/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./DataGridAutocompleteTableFilter"), exports);
+tslib_1.__exportStar(require("./types"), exports);

package/__inner__/cjs/core/filter/table/autocomplete/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/__inner__/cjs/core/filter/table/autocompleteListCard/DataGridAutocompleteListCardTableFilter.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataGridAutocompleteListCardTableFilter = void 0;
+var tslib_1 = require("tslib");
+var base_1 = require("../base");
+var DataGridAutocompleteListCardTableFilter = /** @class */ (function (_super) {
+    tslib_1.__extends(DataGridAutocompleteListCardTableFilter, _super);
+    function DataGridAutocompleteListCardTableFilter(_a) {
+        var _this = this;
+        var options = _a.options, type = _a.type, render = _a.render, other = tslib_1.__rest(_a, ["options", "type", "render"]);
+        _this = _super.call(this, tslib_1.__assign({}, other)) || this;
+        _this.render = render;
+        _this.options = options !== null && options !== void 0 ? options : [];
+        _this.type = type !== null && type !== void 0 ? type : 'multiple';
+        return _this;
+    }
+    return DataGridAutocompleteListCardTableFilter;
+}(base_1.DataGridTableFilter));
+exports.DataGridAutocompleteListCardTableFilter = DataGridAutocompleteListCardTableFilter;

package/__inner__/cjs/core/filter/table/autocompleteListCard/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./DataGridAutocompleteListCardTableFilter"), exports);
+tslib_1.__exportStar(require("./types"), exports);

package/__inner__/cjs/core/filter/table/autocompleteListCard/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/__inner__/cjs/core/filter/table/base/DataGridTableFilter.js

@@ -0,0 +1,16 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataGridTableFilter = void 0;
+var DataGridTableFilter = /** @class */ (function () {
+    function DataGridTableFilter(_a) {
+        var id = _a.id, column = _a.column, name = _a.name, group = _a.group, render = _a.render;
+        this.column = column !== null && column !== void 0 ? column : null;
+        this.id = "filter_".concat(this.column ? "".concat(this.column.id, ".") : '').concat(id);
+        this.name = name !== null && name !== void 0 ? name : null;
+        this.group = group !== null && group !== void 0 ? group : 'main';
+        this.render = render !== null && render !== void 0 ? render : null;
+    }
+    return DataGridTableFilter;
+}());
+exports.DataGridTableFilter = DataGridTableFilter;