@ozen-ui/data-grid 0.73.0

package/__inner__/esm/core/filter/store/DataGridStoreFilters.js

@@ -0,0 +1,170 @@
+import { __read, __spreadArray } from "tslib";
+import { makeAutoObservable } from 'mobx';
+import { EventBus } from '../../../shared';
+var DataGridStoreFilters = /** @class */ (function () {
+    function DataGridStoreFilters(filterInfo, context) {
+        this.filters = [];
+        this.eventBus = new EventBus();
+        this.context = context;
+        this.logic = filterInfo.logic;
+        makeAutoObservable(this);
+    }
+    DataGridStoreFilters.prototype.register = function () {
+        this.filters.forEach(function (filter) {
+            filter.register();
+        });
+    };
+    DataGridStoreFilters.prototype.addFilter = function (filter) {
+        this.filters.push(filter);
+    };
+    DataGridStoreFilters.prototype.findFilter = function (tableFilter) {
+        var filter = this.filterById[tableFilter.id];
+        if (!filter) {
+            throw new Error("Filter with id \"".concat(tableFilter.id, "\" not found."));
+        }
+        return filter;
+    };
+    Object.defineProperty(DataGridStoreFilters.prototype, "filterById", {
+        get: function () {
+            var filterById = {};
+            this.filters.forEach(function (filter) {
+                filterById[filter.id] = filter;
+            });
+            return filterById;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DataGridStoreFilters.prototype.setLogic = function (logic) {
+        this.logic = logic;
+    };
+    Object.defineProperty(DataGridStoreFilters.prototype, "isImmediate", {
+        get: function () {
+            return this.logic === 'immediate';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreFilters.prototype, "isConfirmable", {
+        get: function () {
+            return this.logic === 'confirmable';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreFilters.prototype, "isSomeMainEdited", {
+        get: function () {
+            return __spreadArray(__spreadArray([], __read(this.mainFilters), false), __read(this.subMainFilters), false).some(function (filter) { return filter.isEditedLocal; });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreFilters.prototype, "isSomeAdditionalEdited", {
+        get: function () {
+            return this.additionalFilters.some(function (filter) { return filter.isEditedLocal; });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreFilters.prototype, "isSomeEdited", {
+        get: function () {
+            return this.isSomeMainEdited || this.isSomeAdditionalEdited;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreFilters.prototype, "isSomeAllFiltersEdited", {
+        get: function () {
+            return this.filters.some(function (filter) { return filter.isEditedAllFilter; });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreFilters.prototype, "isSomeMainActive", {
+        get: function () {
+            return __spreadArray(__spreadArray([], __read(this.mainFilters), false), __read(this.subMainFilters), false).some(function (filter) { return filter.isActive; });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreFilters.prototype, "isSomeAdditionalActive", {
+        get: function () {
+            return this.additionalFilters.some(function (filter) { return filter.isActive; });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreFilters.prototype, "isSomeActive", {
+        get: function () {
+            return this.isSomeMainActive || this.isSomeAdditionalActive;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreFilters.prototype, "mainFilters", {
+        get: function () {
+            return this.filters.filter(function (filter) { return filter.isMain; });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreFilters.prototype, "subMainFilters", {
+        get: function () {
+            return this.filters.filter(function (filter) { return filter.isSubMain; });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreFilters.prototype, "additionalFilters", {
+        get: function () {
+            return this.filters.filter(function (filter) { return filter.isAdditional; });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DataGridStoreFilters.prototype.applyAdditionalLocals = function () {
+        this.additionalFilters.forEach(function (filter) {
+            filter.applyLocal();
+        });
+    };
+    DataGridStoreFilters.prototype.applyMainLocals = function () {
+        __spreadArray(__spreadArray([], __read(this.mainFilters), false), __read(this.subMainFilters), false).forEach(function (filter) {
+            filter.applyLocal();
+        });
+    };
+    DataGridStoreFilters.prototype.applyAllFilters = function () {
+        this.filters.forEach(function (filter) {
+            filter.applyAllFilter();
+        });
+    };
+    DataGridStoreFilters.prototype.applyLocals = function () {
+        this.applyAdditionalLocals();
+        this.applyMainLocals();
+    };
+    DataGridStoreFilters.prototype.resetAll = function () {
+        this.filters.forEach(function (filter) {
+            filter.reset();
+        });
+    };
+    DataGridStoreFilters.prototype.resetMainLocals = function () {
+        __spreadArray(__spreadArray([], __read(this.mainFilters), false), __read(this.subMainFilters), false).forEach(function (filter) {
+            filter.resetLocal();
+        });
+    };
+    DataGridStoreFilters.prototype.resetAdditionalLocals = function () {
+        this.additionalFilters.forEach(function (filter) {
+            filter.resetLocal();
+        });
+    };
+    DataGridStoreFilters.prototype.resetAllLocals = function () {
+        this.resetAdditionalLocals();
+        this.resetMainLocals();
+    };
+    DataGridStoreFilters.prototype.resetAllFilters = function () {
+        this.filters.forEach(function (filter) {
+            filter.resetAllFilter();
+        });
+    };
+    return DataGridStoreFilters;
+}());
+export { DataGridStoreFilters };

package/__inner__/esm/core/filter/store/autocomplete/DataGridStoreAutocompleteFilter.js

@@ -0,0 +1,30 @@
+import { __extends } from "tslib";
+import { renderContent } from '@ozen-ui/kit/utils';
+import { makeObservable, observable } from 'mobx';
+import { DataGridStoreBaseSelectFilter } from '../select';
+var DataGridStoreAutocompleteFilter = /** @class */ (function (_super) {
+    __extends(DataGridStoreAutocompleteFilter, _super);
+    function DataGridStoreAutocompleteFilter(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 renderContent({
+                    content: rawRender,
+                    props: { filter: _this, context: _this.context, type: type },
+                });
+            }
+            : null;
+        makeObservable(_this, {
+            options: observable,
+            type: observable,
+            render: observable,
+        });
+        return _this;
+    }
+    return DataGridStoreAutocompleteFilter;
+}(DataGridStoreBaseSelectFilter));
+export { DataGridStoreAutocompleteFilter };

package/__inner__/esm/core/filter/store/autocomplete/index.js

@@ -0,0 +1,2 @@
+export * from './DataGridStoreAutocompleteFilter';
+export * from './types';

package/__inner__/esm/core/filter/store/autocomplete/types.js

@@ -0,0 +1,3 @@
+import { __assign } from "tslib";
+import { dataGridStoreSelectFilterEvent } from '../select';
+export var dataGridStoreAutocompleteFilterEvent = __assign({}, dataGridStoreSelectFilterEvent);

package/__inner__/esm/core/filter/store/autocompleteListCard/DataGridStoreAutocompleteListCardFilter.js

@@ -0,0 +1,27 @@
+import { __extends } from "tslib";
+import { renderContent } from '@ozen-ui/kit/utils';
+import { makeObservable, observable } from 'mobx';
+import { DataGridStoreBaseSelectFilter } from '../select';
+var DataGridStoreAutocompleteListCardFilter = /** @class */ (function (_super) {
+    __extends(DataGridStoreAutocompleteListCardFilter, _super);
+    function DataGridStoreAutocompleteListCardFilter(filter, context) {
+        var _this = _super.call(this, filter, context) || this;
+        _this.options = filter.options;
+        _this.type = filter.type;
+        _this.render = function (_a) {
+            var type = _a.type;
+            return renderContent({
+                content: filter.render,
+                props: { filter: _this, context: _this.context, type: type },
+            });
+        };
+        makeObservable(_this, {
+            options: observable,
+            type: observable,
+            render: observable,
+        });
+        return _this;
+    }
+    return DataGridStoreAutocompleteListCardFilter;
+}(DataGridStoreBaseSelectFilter));
+export { DataGridStoreAutocompleteListCardFilter };

package/__inner__/esm/core/filter/store/autocompleteListCard/index.js

@@ -0,0 +1,2 @@
+export * from './DataGridStoreAutocompleteListCardFilter';
+export * from './types';

package/__inner__/esm/core/filter/store/autocompleteListCard/types.js

@@ -0,0 +1,3 @@
+import { __assign } from "tslib";
+import { dataGridStoreSelectFilterEvent } from '../select';
+export var dataGridStoreAutocompleteListCardFilterEvent = __assign({}, dataGridStoreSelectFilterEvent);

package/__inner__/esm/core/filter/store/base/DataGridStoreFilter.js

@@ -0,0 +1,158 @@
+import cloneDeep from 'lodash.clonedeep';
+import { action, computed, makeObservable, observable, toJS } from 'mobx';
+import { EventBus } from '../../../../shared';
+var DataGridStoreFilter = /** @class */ (function () {
+    function DataGridStoreFilter(filter, context) {
+        this.eventBus = new EventBus();
+        this.context = context;
+        this.id = filter.id;
+        this.rawName = filter.name;
+        this.group = filter.group;
+        this.column = null;
+        makeObservable(this, {
+            id: observable,
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-expect-error
+            rawName: observable,
+            column: observable,
+            group: observable,
+            context: observable,
+            setGroup: action,
+            setColumn: action,
+            setValue: action,
+            setLocalValue: action,
+            setAllFilterValue: action,
+            resetLocal: action,
+            resetAllFilter: action,
+            applyLocal: action,
+            applyAllFilter: action,
+            setValueByType: action,
+            name: computed,
+            isMain: computed,
+            isAdditional: computed,
+            isEditedLocal: computed,
+            isEditedAllFilter: computed,
+            isCustomRender: computed,
+        });
+    }
+    DataGridStoreFilter.prototype.register = function () { };
+    Object.defineProperty(DataGridStoreFilter.prototype, "isCustomRender", {
+        get: function () {
+            return !!this.render;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DataGridStoreFilter.prototype.setValue = function (value) {
+        var oldValue = this.value;
+        this.value = value;
+        this.setLocalValue(cloneDeep(toJS(value)));
+        this.setAllFilterValue(cloneDeep(toJS(value)));
+        if (!this.isEqualValues(oldValue, value)) {
+            this.eventBus.publish('changeValue', value);
+            this.context.filters.eventBus.publish('changeFilter', this);
+        }
+    };
+    DataGridStoreFilter.prototype.setLocalValue = function (value) {
+        var oldValue = this.localValue;
+        this.localValue = value;
+        if (!this.isEqualValues(oldValue, value)) {
+            this.eventBus.publish('changeLocalValue', value);
+        }
+    };
+    DataGridStoreFilter.prototype.setAllFilterValue = function (value) {
+        var oldValue = this.allFilterValue;
+        this.allFilterValue = value;
+        if (!this.isEqualValues(oldValue, value)) {
+            this.eventBus.publish('changeAllFilterValue', value);
+        }
+    };
+    DataGridStoreFilter.prototype.resetLocal = function () {
+        this.setLocalValue(this.value);
+    };
+    DataGridStoreFilter.prototype.resetAllFilter = function () {
+        this.setAllFilterValue(this.value);
+    };
+    DataGridStoreFilter.prototype.applyLocal = function () {
+        this.setValue(this.localValue);
+    };
+    DataGridStoreFilter.prototype.applyAllFilter = function () {
+        this.setValue(this.allFilterValue);
+    };
+    DataGridStoreFilter.prototype.setValueByType = function (value, type) {
+        if (type === 'local') {
+            this.setLocalValue(value);
+            return;
+        }
+        if (type === 'allFilter') {
+            this.setAllFilterValue(value);
+            return;
+        }
+        this.setValue(value);
+    };
+    DataGridStoreFilter.prototype.valueByType = function (type) {
+        if (type === 'local') {
+            return this.localValue;
+        }
+        if (type === 'allFilter') {
+            return this.allFilterValue;
+        }
+        return this.value;
+    };
+    DataGridStoreFilter.prototype.setGroup = function (group) {
+        this.group = group;
+    };
+    DataGridStoreFilter.prototype.setColumn = function (column) {
+        this.column = column;
+    };
+    Object.defineProperty(DataGridStoreFilter.prototype, "isEditedLocal", {
+        get: function () {
+            return !this.isEqualValues(this.localValue, this.value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreFilter.prototype, "isEditedAllFilter", {
+        get: function () {
+            return !this.isEqualValues(this.allFilterValue, this.value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreFilter.prototype, "isMain", {
+        get: function () {
+            return this.group === 'main';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreFilter.prototype, "isSubMain", {
+        get: function () {
+            return this.group === 'sub-main';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreFilter.prototype, "isAdditional", {
+        get: function () {
+            return this.group === 'additional';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataGridStoreFilter.prototype, "name", {
+        get: function () {
+            if (this.rawName) {
+                return this.rawName;
+            }
+            if (this.column) {
+                return this.column.name;
+            }
+            return this.id;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return DataGridStoreFilter;
+}());
+export { DataGridStoreFilter };

package/__inner__/esm/core/filter/store/base/index.js

@@ -0,0 +1,2 @@
+export * from './DataGridStoreFilter';
+export * from './types';

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

@@ -0,0 +1,10 @@
+export var dataGridStoreFilterValueType = [
+    'default',
+    'local',
+    'allFilter',
+];
+export var dataGridStoreFilterEvent = {
+    CHANGE_VALUE: 'changeValue',
+    CHANGE_LOCAL_VALUE: 'changeLocalValue',
+    CHANGE_ALL_FILTER_VALUE: 'changeAllFilterValue',
+};

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

@@ -0,0 +1,112 @@
+import { __extends } from "tslib";
+import { renderContent } from '@ozen-ui/kit/utils';
+import cloneDeep from 'lodash.clonedeep';
+import isEqual from 'lodash.isequal';
+import { action, computed, makeObservable, observable, toJS } from 'mobx';
+import { DataGridStoreFilter } from '../base';
+import { isDateFilterRangeValue, isDateFilterSingleValue } from './utils';
+var DataGridStoreDateFilter = /** @class */ (function (_super) {
+    __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 renderContent({
+                    content: rawRender,
+                    props: { filter: _this, context: _this.context, type: type },
+                });
+            }
+            : null;
+        makeObservable(_this, {
+            min: observable,
+            max: observable,
+            type: observable,
+            value: observable,
+            localValue: observable,
+            allFilterValue: observable,
+            setMin: action,
+            setMax: action,
+            setType: action,
+            isActive: computed,
+            render: observable,
+        });
+        return _this;
+    }
+    Object.defineProperty(DataGridStoreDateFilter.prototype, "isActive", {
+        get: function () {
+            if (isDateFilterRangeValue(this.value)) {
+                return !!this.value.from || !!this.value.to;
+            }
+            return this.value !== null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DataGridStoreDateFilter.prototype.processValue = function (value) {
+        if (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 isEqual(toJS(processedValue1), 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 = cloneDeep(this.min);
+        this.min = min;
+        if (!isEqual(oldMin, min)) {
+            this.eventBus.publish('changeMin', min);
+        }
+    };
+    DataGridStoreDateFilter.prototype.setMax = function (max) {
+        var oldMax = cloneDeep(this.max);
+        this.max = max;
+        if (!isEqual(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' && isDateFilterRangeValue(this.value)) {
+            this.setValue((_a = this.value.from) !== null && _a !== void 0 ? _a : null);
+        }
+        else if (this.type === 'range' && isDateFilterSingleValue(this.value)) {
+            this.setValue({
+                from: this.value,
+                to: null,
+            });
+        }
+        if (oldType !== type) {
+            this.eventBus.publish('changeType', type);
+        }
+    };
+    return DataGridStoreDateFilter;
+}(DataGridStoreFilter));
+export { DataGridStoreDateFilter };

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

@@ -0,0 +1,3 @@
+export * from './DataGridStoreDateFilter';
+export * from './types';
+export * from './utils';

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

@@ -0,0 +1,3 @@
+import { __assign } from "tslib";
+import { dataGridStoreFilterEvent } from '../base';
+export var dataGridStoreDateFilterEvent = __assign(__assign({}, dataGridStoreFilterEvent), { CHANGE_TYPE: 'changeType', CHANGE_MIN: 'changeMin', CHANGE_MAX: 'changeMax' });

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

@@ -0,0 +1,6 @@
+import { isPlainObject } from '@ozen-ui/kit/utils';
+import isDate from 'lodash.isdate';
+export var isDateFilterRangeValue = function (value) {
+    return isPlainObject(value) && 'from' && value && 'to' in value;
+};
+export var isDateFilterSingleValue = function (value) { return isDate(value); };

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

@@ -0,0 +1,8 @@
+export * from './autocomplete';
+export * from './autocompleteListCard';
+export * from './base';
+export * from './date';
+export * from './inputs';
+export * from './select';
+export * from './DataGridStoreFilters';
+export * from './types';

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

@@ -0,0 +1,13 @@
+import { __extends } from "tslib";
+import { DataGridStoreInputFilter } from './base';
+var DataGridStoreNumberFilter = /** @class */ (function (_super) {
+    __extends(DataGridStoreNumberFilter, _super);
+    function DataGridStoreNumberFilter() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    DataGridStoreNumberFilter.prototype.resetValue = function () {
+        this.setValue(null);
+    };
+    return DataGridStoreNumberFilter;
+}(DataGridStoreInputFilter));
+export { DataGridStoreNumberFilter };

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

@@ -0,0 +1,13 @@
+import { __extends } from "tslib";
+import { DataGridStoreInputFilter } from './base';
+var DataGridStoreStringFilter = /** @class */ (function (_super) {
+    __extends(DataGridStoreStringFilter, _super);
+    function DataGridStoreStringFilter() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    DataGridStoreStringFilter.prototype.resetValue = function () {
+        this.setValue(null);
+    };
+    return DataGridStoreStringFilter;
+}(DataGridStoreInputFilter));
+export { DataGridStoreStringFilter };