@netgrif/components-core 6.0.1

package/esm5/lib/search/models/operator/less-than-equal-date.js

@@ -0,0 +1,31 @@
+import { __extends } from "tslib";
+import { Operator } from './operator';
+import moment from 'moment';
+import { Operators } from './operators';
+import { LessThanDate } from './less-than-date';
+/**
+ * Less or equal than operator for Date fields
+ */
+var LessThanEqualDate = /** @class */ (function (_super) {
+    __extends(LessThanEqualDate, _super);
+    function LessThanEqualDate(operators) {
+        var _this = _super.call(this, 1) || this;
+        _this.lessThan = operators.getOperator(LessThanDate);
+        return _this;
+    }
+    LessThanEqualDate.prototype.createQuery = function (elasticKeywords, args) {
+        this.checkArgumentsCount(args);
+        var arg = moment(args[0]);
+        arg.date(arg.date() + 1);
+        return this.lessThan.createQuery(elasticKeywords, [arg]);
+    };
+    LessThanEqualDate.prototype.getOperatorNameTemplate = function () {
+        return ['search.operator.lessThanEqual', Operator.INPUT_PLACEHOLDER];
+    };
+    LessThanEqualDate.prototype.serialize = function () {
+        return Operators.LESS_THAN_EQUAL_DATE;
+    };
+    return LessThanEqualDate;
+}(Operator));
+export { LessThanEqualDate };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/search/models/operator/less-than-equal.js

@@ -0,0 +1,21 @@
+import { __extends } from "tslib";
+import { Operator } from './operator';
+import { Operators } from './operators';
+/**
+ * Less or equal than operator for numeric fields
+ */
+var LessThanEqual = /** @class */ (function (_super) {
+    __extends(LessThanEqual, _super);
+    function LessThanEqual() {
+        return _super.call(this, 1, '<=') || this;
+    }
+    LessThanEqual.prototype.getOperatorNameTemplate = function () {
+        return ['search.operator.lessThanEqual', Operator.INPUT_PLACEHOLDER];
+    };
+    LessThanEqual.prototype.serialize = function () {
+        return Operators.LESS_THAN_EQUAL;
+    };
+    return LessThanEqual;
+}(Operator));
+export { LessThanEqual };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGVzcy10aGFuLWVxdWFsLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3NlYXJjaC9tb2RlbHMvb3BlcmF0b3IvbGVzcy10aGFuLWVxdWFsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sWUFBWSxDQUFDO0FBQ3BDLE9BQU8sRUFBQyxTQUFTLEVBQUMsTUFBTSxhQUFhLENBQUM7QUFFdEM7O0dBRUc7QUFDSDtJQUFtQyxpQ0FBZ0I7SUFFL0M7ZUFDSSxrQkFBTSxDQUFDLEVBQUUsSUFBSSxDQUFDO0lBQ2xCLENBQUM7SUFFRCwrQ0FBdUIsR0FBdkI7UUFDSSxPQUFPLENBQUMsK0JBQStCLEVBQUUsUUFBUSxDQUFDLGlCQUFpQixDQUFDLENBQUM7SUFDekUsQ0FBQztJQUVELGlDQUFTLEdBQVQ7UUFDSSxPQUFPLFNBQVMsQ0FBQyxlQUFlLENBQUM7SUFDckMsQ0FBQztJQUdMLG9CQUFDO0FBQUQsQ0FBQyxBQWZELENBQW1DLFFBQVEsR0FlMUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge09wZXJhdG9yfSBmcm9tICcuL29wZXJhdG9yJztcbmltcG9ydCB7T3BlcmF0b3JzfSBmcm9tICcuL29wZXJhdG9ycyc7XG5cbi8qKlxuICogTGVzcyBvciBlcXVhbCB0aGFuIG9wZXJhdG9yIGZvciBudW1lcmljIGZpZWxkc1xuICovXG5leHBvcnQgY2xhc3MgTGVzc1RoYW5FcXVhbCBleHRlbmRzIE9wZXJhdG9yPG51bWJlcj4ge1xuXG4gICAgY29uc3RydWN0b3IoKSB7XG4gICAgICAgIHN1cGVyKDEsICc8PScpO1xuICAgIH1cblxuICAgIGdldE9wZXJhdG9yTmFtZVRlbXBsYXRlKCk6IEFycmF5PHN0cmluZz4ge1xuICAgICAgICByZXR1cm4gWydzZWFyY2gub3BlcmF0b3IubGVzc1RoYW5FcXVhbCcsIE9wZXJhdG9yLklOUFVUX1BMQUNFSE9MREVSXTtcbiAgICB9XG5cbiAgICBzZXJpYWxpemUoKTogT3BlcmF0b3JzIHwgc3RyaW5nIHtcbiAgICAgICAgcmV0dXJuIE9wZXJhdG9ycy5MRVNTX1RIQU5fRVFVQUw7XG4gICAgfVxuXG5cbn1cbiJdfQ==

package/esm5/lib/search/models/operator/less-than.js

@@ -0,0 +1,21 @@
+import { __extends } from "tslib";
+import { Operator } from './operator';
+import { Operators } from './operators';
+/**
+ * A strict less than operator for numeric fields.
+ */
+var LessThan = /** @class */ (function (_super) {
+    __extends(LessThan, _super);
+    function LessThan() {
+        return _super.call(this, 1, '<') || this;
+    }
+    LessThan.prototype.getOperatorNameTemplate = function () {
+        return ['search.operator.lessThan', Operator.INPUT_PLACEHOLDER];
+    };
+    LessThan.prototype.serialize = function () {
+        return Operators.LESS_THAN;
+    };
+    return LessThan;
+}(Operator));
+export { LessThan };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGVzcy10aGFuLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3NlYXJjaC9tb2RlbHMvb3BlcmF0b3IvbGVzcy10aGFuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sWUFBWSxDQUFDO0FBQ3BDLE9BQU8sRUFBQyxTQUFTLEVBQUMsTUFBTSxhQUFhLENBQUM7QUFFdEM7O0dBRUc7QUFDSDtJQUE4Qiw0QkFBZ0I7SUFDMUM7ZUFDSSxrQkFBTSxDQUFDLEVBQUUsR0FBRyxDQUFDO0lBQ2pCLENBQUM7SUFFRCwwQ0FBdUIsR0FBdkI7UUFDSSxPQUFPLENBQUMsMEJBQTBCLEVBQUUsUUFBUSxDQUFDLGlCQUFpQixDQUFDLENBQUM7SUFDcEUsQ0FBQztJQUVELDRCQUFTLEdBQVQ7UUFDSSxPQUFPLFNBQVMsQ0FBQyxTQUFTLENBQUM7SUFDL0IsQ0FBQztJQUNMLGVBQUM7QUFBRCxDQUFDLEFBWkQsQ0FBOEIsUUFBUSxHQVlyQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7T3BlcmF0b3J9IGZyb20gJy4vb3BlcmF0b3InO1xuaW1wb3J0IHtPcGVyYXRvcnN9IGZyb20gJy4vb3BlcmF0b3JzJztcblxuLyoqXG4gKiBBIHN0cmljdCBsZXNzIHRoYW4gb3BlcmF0b3IgZm9yIG51bWVyaWMgZmllbGRzLlxuICovXG5leHBvcnQgY2xhc3MgTGVzc1RoYW4gZXh0ZW5kcyBPcGVyYXRvcjxudW1iZXI+IHtcbiAgICBjb25zdHJ1Y3RvcigpIHtcbiAgICAgICAgc3VwZXIoMSwgJzwnKTtcbiAgICB9XG5cbiAgICBnZXRPcGVyYXRvck5hbWVUZW1wbGF0ZSgpOiBBcnJheTxzdHJpbmc+IHtcbiAgICAgICAgcmV0dXJuIFsnc2VhcmNoLm9wZXJhdG9yLmxlc3NUaGFuJywgT3BlcmF0b3IuSU5QVVRfUExBQ0VIT0xERVJdO1xuICAgIH1cblxuICAgIHNlcmlhbGl6ZSgpOiBPcGVyYXRvcnMgfCBzdHJpbmcge1xuICAgICAgICByZXR1cm4gT3BlcmF0b3JzLkxFU1NfVEhBTjtcbiAgICB9XG59XG4iXX0=

package/esm5/lib/search/models/operator/like.js

@@ -0,0 +1,33 @@
+import { __extends } from "tslib";
+import { Operator } from './operator';
+import { Query } from '../query/query';
+import { Operators } from './operators';
+/**
+ * A fuzzy search operator for string fields.
+ *
+ * Behaves differently for strings with spaces and without.
+ * With spaces searches for matches containing the tokenized strings.
+ * Without spaces searches for strings within the default edit distance.
+ * See [docs]{@link https://www.elastic.co/guide/en/elasticsearch/reference/6.6/query-dsl-query-string-query.html#_fuzziness}
+ * for more information.
+ */
+var Like = /** @class */ (function (_super) {
+    __extends(Like, _super);
+    function Like() {
+        return _super.call(this, 1) || this;
+    }
+    Like.prototype.createQuery = function (elasticKeywords, args) {
+        this.checkArgumentsCount(args);
+        var escaped = Operator.escapeInput(args[0]);
+        return Operator.forEachKeyword(elasticKeywords, function (keyword) { return escaped.wasEscaped ? new Query("(" + keyword + ":" + escaped.value + ")") : new Query("(" + keyword + ":" + escaped.value + "~)"); });
+    };
+    Like.prototype.getOperatorNameTemplate = function () {
+        return ['search.operator.like', Operator.INPUT_PLACEHOLDER];
+    };
+    Like.prototype.serialize = function () {
+        return Operators.LIKE;
+    };
+    return Like;
+}(Operator));
+export { Like };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/search/models/operator/more-than-date-time.js

@@ -0,0 +1,34 @@
+import { __extends } from "tslib";
+import { Operator } from './operator';
+import moment from 'moment';
+import { MoreThan } from './more-than';
+import { Operators } from './operators';
+/**
+ * A strict greater than operator for DateTime fields
+ */
+var MoreThanDateTime = /** @class */ (function (_super) {
+    __extends(MoreThanDateTime, _super);
+    function MoreThanDateTime(operators) {
+        var _this = _super.call(this, 1) || this;
+        _this.moreThan = operators.getOperator(MoreThan);
+        return _this;
+    }
+    MoreThanDateTime.prototype.createQuery = function (elasticKeywords, args) {
+        this.checkArgumentsCount(args);
+        var arg = moment(args[0]);
+        arg.milliseconds(0);
+        arg.seconds(0);
+        arg.minutes(arg.minutes() + 1);
+        arg.milliseconds(-1);
+        return this.moreThan.createQuery(elasticKeywords, [arg.valueOf()]);
+    };
+    MoreThanDateTime.prototype.getOperatorNameTemplate = function () {
+        return ['search.operator.moreThan', Operator.INPUT_PLACEHOLDER];
+    };
+    MoreThanDateTime.prototype.serialize = function () {
+        return Operators.MORE_THAN_DATE_TIME;
+    };
+    return MoreThanDateTime;
+}(Operator));
+export { MoreThanDateTime };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/search/models/operator/more-than-date.js

@@ -0,0 +1,34 @@
+import { __extends } from "tslib";
+import { Operator } from './operator';
+import { MoreThan } from './more-than';
+import moment from 'moment';
+import { clearTimeInformation } from '../../../utility/clear-time-information';
+import { Operators } from './operators';
+/**
+ * A strict greater than operator for Date fields
+ */
+var MoreThanDate = /** @class */ (function (_super) {
+    __extends(MoreThanDate, _super);
+    function MoreThanDate(operators) {
+        var _this = _super.call(this, 1) || this;
+        _this.moreThan = operators.getOperator(MoreThan);
+        return _this;
+    }
+    MoreThanDate.prototype.createQuery = function (elasticKeywords, args) {
+        this.checkArgumentsCount(args);
+        var arg = moment(args[0]);
+        clearTimeInformation(arg);
+        arg.date(arg.date() + 1);
+        arg.milliseconds(-1);
+        return this.moreThan.createQuery(elasticKeywords, [arg.valueOf()]);
+    };
+    MoreThanDate.prototype.getOperatorNameTemplate = function () {
+        return ['search.operator.moreThan', Operator.INPUT_PLACEHOLDER];
+    };
+    MoreThanDate.prototype.serialize = function () {
+        return Operators.MORE_THAN_DATE;
+    };
+    return MoreThanDate;
+}(Operator));
+export { MoreThanDate };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/search/models/operator/more-than-equal-date-time.js

@@ -0,0 +1,32 @@
+import { __extends } from "tslib";
+import { Operator } from './operator';
+import moment from 'moment';
+import { MoreThanEqual } from './more-than-equal';
+import { Operators } from './operators';
+/**
+ * Greater or equal than operator for Datetime fields
+ */
+var MoreThanEqualDateTime = /** @class */ (function (_super) {
+    __extends(MoreThanEqualDateTime, _super);
+    function MoreThanEqualDateTime(operators) {
+        var _this = _super.call(this, 1) || this;
+        _this.moreThanEqual = operators.getOperator(MoreThanEqual);
+        return _this;
+    }
+    MoreThanEqualDateTime.prototype.createQuery = function (elasticKeywords, args) {
+        this.checkArgumentsCount(args);
+        var arg = moment(args[0]);
+        arg.milliseconds(0);
+        arg.seconds(0);
+        return this.moreThanEqual.createQuery(elasticKeywords, [arg.valueOf()]);
+    };
+    MoreThanEqualDateTime.prototype.getOperatorNameTemplate = function () {
+        return ['search.operator.moreThanEqual', Operator.INPUT_PLACEHOLDER];
+    };
+    MoreThanEqualDateTime.prototype.serialize = function () {
+        return Operators.MORE_THAN_EQUAL_DATE_TIME;
+    };
+    return MoreThanEqualDateTime;
+}(Operator));
+export { MoreThanEqualDateTime };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/search/models/operator/more-than-equal-date.js

@@ -0,0 +1,32 @@
+import { __extends } from "tslib";
+import { Operator } from './operator';
+import moment from 'moment';
+import { MoreThanEqual } from './more-than-equal';
+import { Operators } from './operators';
+import { clearTimeInformation } from '../../../utility/clear-time-information';
+/**
+ * Greater or equal than operator for Date fields
+ */
+var MoreThanEqualDate = /** @class */ (function (_super) {
+    __extends(MoreThanEqualDate, _super);
+    function MoreThanEqualDate(operators) {
+        var _this = _super.call(this, 1) || this;
+        _this.moreThanEqual = operators.getOperator(MoreThanEqual);
+        return _this;
+    }
+    MoreThanEqualDate.prototype.createQuery = function (elasticKeywords, args) {
+        this.checkArgumentsCount(args);
+        var arg = moment(args[0]);
+        clearTimeInformation(arg);
+        return this.moreThanEqual.createQuery(elasticKeywords, [arg.valueOf()]);
+    };
+    MoreThanEqualDate.prototype.getOperatorNameTemplate = function () {
+        return ['search.operator.moreThanEqual', Operator.INPUT_PLACEHOLDER];
+    };
+    MoreThanEqualDate.prototype.serialize = function () {
+        return Operators.MORE_THAN_EQUAL_DATE;
+    };
+    return MoreThanEqualDate;
+}(Operator));
+export { MoreThanEqualDate };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/search/models/operator/more-than-equal.js

@@ -0,0 +1,21 @@
+import { __extends } from "tslib";
+import { Operator } from './operator';
+import { Operators } from './operators';
+/**
+ * Greater or equal than operator for numeric fields
+ */
+var MoreThanEqual = /** @class */ (function (_super) {
+    __extends(MoreThanEqual, _super);
+    function MoreThanEqual() {
+        return _super.call(this, 1, '>=') || this;
+    }
+    MoreThanEqual.prototype.getOperatorNameTemplate = function () {
+        return ['search.operator.moreThanEqual', Operator.INPUT_PLACEHOLDER];
+    };
+    MoreThanEqual.prototype.serialize = function () {
+        return Operators.LESS_THAN_EQUAL;
+    };
+    return MoreThanEqual;
+}(Operator));
+export { MoreThanEqual };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9yZS10aGFuLWVxdWFsLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3NlYXJjaC9tb2RlbHMvb3BlcmF0b3IvbW9yZS10aGFuLWVxdWFsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sWUFBWSxDQUFDO0FBQ3BDLE9BQU8sRUFBQyxTQUFTLEVBQUMsTUFBTSxhQUFhLENBQUM7QUFFdEM7O0dBRUc7QUFDSDtJQUFtQyxpQ0FBZ0I7SUFFL0M7ZUFDSSxrQkFBTSxDQUFDLEVBQUUsSUFBSSxDQUFDO0lBQ2xCLENBQUM7SUFFRCwrQ0FBdUIsR0FBdkI7UUFDSSxPQUFPLENBQUMsK0JBQStCLEVBQUUsUUFBUSxDQUFDLGlCQUFpQixDQUFDLENBQUM7SUFDekUsQ0FBQztJQUVELGlDQUFTLEdBQVQ7UUFDSSxPQUFPLFNBQVMsQ0FBQyxlQUFlLENBQUM7SUFDckMsQ0FBQztJQUdMLG9CQUFDO0FBQUQsQ0FBQyxBQWZELENBQW1DLFFBQVEsR0FlMUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge09wZXJhdG9yfSBmcm9tICcuL29wZXJhdG9yJztcbmltcG9ydCB7T3BlcmF0b3JzfSBmcm9tICcuL29wZXJhdG9ycyc7XG5cbi8qKlxuICogR3JlYXRlciBvciBlcXVhbCB0aGFuIG9wZXJhdG9yIGZvciBudW1lcmljIGZpZWxkc1xuICovXG5leHBvcnQgY2xhc3MgTW9yZVRoYW5FcXVhbCBleHRlbmRzIE9wZXJhdG9yPG51bWJlcj4ge1xuXG4gICAgY29uc3RydWN0b3IoKSB7XG4gICAgICAgIHN1cGVyKDEsICc+PScpO1xuICAgIH1cblxuICAgIGdldE9wZXJhdG9yTmFtZVRlbXBsYXRlKCk6IEFycmF5PHN0cmluZz4ge1xuICAgICAgICByZXR1cm4gWydzZWFyY2gub3BlcmF0b3IubW9yZVRoYW5FcXVhbCcsIE9wZXJhdG9yLklOUFVUX1BMQUNFSE9MREVSXTtcbiAgICB9XG5cbiAgICBzZXJpYWxpemUoKTogT3BlcmF0b3JzIHwgc3RyaW5nIHtcbiAgICAgICAgcmV0dXJuIE9wZXJhdG9ycy5MRVNTX1RIQU5fRVFVQUw7XG4gICAgfVxuXG5cbn1cbiJdfQ==

package/esm5/lib/search/models/operator/more-than.js

@@ -0,0 +1,21 @@
+import { __extends } from "tslib";
+import { Operator } from './operator';
+import { Operators } from './operators';
+/**
+ * A strict greater than operator for numeric fields.
+ */
+var MoreThan = /** @class */ (function (_super) {
+    __extends(MoreThan, _super);
+    function MoreThan() {
+        return _super.call(this, 1, '>') || this;
+    }
+    MoreThan.prototype.getOperatorNameTemplate = function () {
+        return ['search.operator.moreThan', Operator.INPUT_PLACEHOLDER];
+    };
+    MoreThan.prototype.serialize = function () {
+        return Operators.MORE_THAN;
+    };
+    return MoreThan;
+}(Operator));
+export { MoreThan };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9yZS10aGFuLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3NlYXJjaC9tb2RlbHMvb3BlcmF0b3IvbW9yZS10aGFuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sWUFBWSxDQUFDO0FBQ3BDLE9BQU8sRUFBQyxTQUFTLEVBQUMsTUFBTSxhQUFhLENBQUM7QUFFdEM7O0dBRUc7QUFDSDtJQUE4Qiw0QkFBZ0I7SUFDMUM7ZUFDSSxrQkFBTSxDQUFDLEVBQUUsR0FBRyxDQUFDO0lBQ2pCLENBQUM7SUFFRCwwQ0FBdUIsR0FBdkI7UUFDSSxPQUFPLENBQUMsMEJBQTBCLEVBQUUsUUFBUSxDQUFDLGlCQUFpQixDQUFDLENBQUM7SUFDcEUsQ0FBQztJQUVELDRCQUFTLEdBQVQ7UUFDSSxPQUFPLFNBQVMsQ0FBQyxTQUFTLENBQUM7SUFDL0IsQ0FBQztJQUNMLGVBQUM7QUFBRCxDQUFDLEFBWkQsQ0FBOEIsUUFBUSxHQVlyQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7T3BlcmF0b3J9IGZyb20gJy4vb3BlcmF0b3InO1xuaW1wb3J0IHtPcGVyYXRvcnN9IGZyb20gJy4vb3BlcmF0b3JzJztcblxuLyoqXG4gKiBBIHN0cmljdCBncmVhdGVyIHRoYW4gb3BlcmF0b3IgZm9yIG51bWVyaWMgZmllbGRzLlxuICovXG5leHBvcnQgY2xhc3MgTW9yZVRoYW4gZXh0ZW5kcyBPcGVyYXRvcjxudW1iZXI+IHtcbiAgICBjb25zdHJ1Y3RvcigpIHtcbiAgICAgICAgc3VwZXIoMSwgJz4nKTtcbiAgICB9XG5cbiAgICBnZXRPcGVyYXRvck5hbWVUZW1wbGF0ZSgpOiBBcnJheTxzdHJpbmc+IHtcbiAgICAgICAgcmV0dXJuIFsnc2VhcmNoLm9wZXJhdG9yLm1vcmVUaGFuJywgT3BlcmF0b3IuSU5QVVRfUExBQ0VIT0xERVJdO1xuICAgIH1cblxuICAgIHNlcmlhbGl6ZSgpOiBPcGVyYXRvcnMgfCBzdHJpbmcge1xuICAgICAgICByZXR1cm4gT3BlcmF0b3JzLk1PUkVfVEhBTjtcbiAgICB9XG59XG4iXX0=

package/esm5/lib/search/models/operator/not-equals-date-time.js

@@ -0,0 +1,29 @@
+import { __extends } from "tslib";
+import { Operator } from './operator';
+import { Query } from '../query/query';
+import { Operators } from './operators';
+import { EqualsDateTime } from './equals-date-time';
+var NotEqualsDateTime = /** @class */ (function (_super) {
+    __extends(NotEqualsDateTime, _super);
+    function NotEqualsDateTime(operators) {
+        var _this = _super.call(this, 1) || this;
+        _this.equals = operators.getOperator(EqualsDateTime);
+        return _this;
+    }
+    NotEqualsDateTime.prototype.createQuery = function (elasticKeywords, args) {
+        var equalsQuery = this.equals.createQuery(elasticKeywords, args);
+        if (equalsQuery.isEmpty) {
+            return equalsQuery;
+        }
+        return new Query("(!" + equalsQuery.value + ")");
+    };
+    NotEqualsDateTime.prototype.getOperatorNameTemplate = function () {
+        return ['search.operator.notEquals', Operator.INPUT_PLACEHOLDER];
+    };
+    NotEqualsDateTime.prototype.serialize = function () {
+        return Operators.NOT_EQUALS_DATE_TIME;
+    };
+    return NotEqualsDateTime;
+}(Operator));
+export { NotEqualsDateTime };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/search/models/operator/not-equals-date.js

@@ -0,0 +1,32 @@
+import { __extends } from "tslib";
+import { Operator } from './operator';
+import { Query } from '../query/query';
+import { EqualsDate } from './equals-date';
+import { Operators } from './operators';
+/**
+ * Inequality operator for Date fields. Will match if the field has a date with different day than the provided date.
+ */
+var NotEqualsDate = /** @class */ (function (_super) {
+    __extends(NotEqualsDate, _super);
+    function NotEqualsDate(operators) {
+        var _this = _super.call(this, 1) || this;
+        _this.equals = operators.getOperator(EqualsDate);
+        return _this;
+    }
+    NotEqualsDate.prototype.createQuery = function (elasticKeywords, args) {
+        var equalsQuery = this.equals.createQuery(elasticKeywords, args);
+        if (equalsQuery.isEmpty) {
+            return equalsQuery;
+        }
+        return new Query("(!" + equalsQuery.value + ")");
+    };
+    NotEqualsDate.prototype.getOperatorNameTemplate = function () {
+        return ['search.operator.notEquals', Operator.INPUT_PLACEHOLDER];
+    };
+    NotEqualsDate.prototype.serialize = function () {
+        return Operators.NOT_EQUALS_DATE;
+    };
+    return NotEqualsDate;
+}(Operator));
+export { NotEqualsDate };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90LWVxdWFscy1kYXRlLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3NlYXJjaC9tb2RlbHMvb3BlcmF0b3Ivbm90LWVxdWFscy1kYXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sWUFBWSxDQUFDO0FBRXBDLE9BQU8sRUFBQyxLQUFLLEVBQUMsTUFBTSxnQkFBZ0IsQ0FBQztBQUNyQyxPQUFPLEVBQUMsVUFBVSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBRXpDLE9BQU8sRUFBQyxTQUFTLEVBQUMsTUFBTSxhQUFhLENBQUM7QUFFdEM7O0dBRUc7QUFDSDtJQUFtQyxpQ0FBZ0I7SUFJL0MsdUJBQVksU0FBMEI7UUFBdEMsWUFDSSxrQkFBTSxDQUFDLENBQUMsU0FFWDtRQURHLEtBQUksQ0FBQyxNQUFNLEdBQUcsU0FBUyxDQUFDLFdBQVcsQ0FBQyxVQUFVLENBQWUsQ0FBQzs7SUFDbEUsQ0FBQztJQUVELG1DQUFXLEdBQVgsVUFBWSxlQUE4QixFQUFFLElBQW1CO1FBQzNELElBQU0sV0FBVyxHQUFHLElBQUksQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLGVBQWUsRUFBRSxJQUFJLENBQUMsQ0FBQztRQUNuRSxJQUFJLFdBQVcsQ0FBQyxPQUFPLEVBQUU7WUFDckIsT0FBTyxXQUFXLENBQUM7U0FDdEI7UUFDRCxPQUFPLElBQUksS0FBSyxDQUFDLE9BQUssV0FBVyxDQUFDLEtBQUssTUFBRyxDQUFDLENBQUM7SUFDaEQsQ0FBQztJQUVELCtDQUF1QixHQUF2QjtRQUNJLE9BQU8sQ0FBQywyQkFBMkIsRUFBRSxRQUFRLENBQUMsaUJBQWlCLENBQUMsQ0FBQztJQUNyRSxDQUFDO0lBRUQsaUNBQVMsR0FBVDtRQUNJLE9BQU8sU0FBUyxDQUFDLGVBQWUsQ0FBQztJQUNyQyxDQUFDO0lBQ0wsb0JBQUM7QUFBRCxDQUFDLEFBeEJELENBQW1DLFFBQVEsR0F3QjFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtPcGVyYXRvcn0gZnJvbSAnLi9vcGVyYXRvcic7XG5pbXBvcnQge09wZXJhdG9yU2VydmljZX0gZnJvbSAnLi4vLi4vb3BlcmF0b3Itc2VydmljZS9vcGVyYXRvci5zZXJ2aWNlJztcbmltcG9ydCB7UXVlcnl9IGZyb20gJy4uL3F1ZXJ5L3F1ZXJ5JztcbmltcG9ydCB7RXF1YWxzRGF0ZX0gZnJvbSAnLi9lcXVhbHMtZGF0ZSc7XG5pbXBvcnQge01vbWVudH0gZnJvbSAnbW9tZW50JztcbmltcG9ydCB7T3BlcmF0b3JzfSBmcm9tICcuL29wZXJhdG9ycyc7XG5cbi8qKlxuICogSW5lcXVhbGl0eSBvcGVyYXRvciBmb3IgRGF0ZSBmaWVsZHMuIFdpbGwgbWF0Y2ggaWYgdGhlIGZpZWxkIGhhcyBhIGRhdGUgd2l0aCBkaWZmZXJlbnQgZGF5IHRoYW4gdGhlIHByb3ZpZGVkIGRhdGUuXG4gKi9cbmV4cG9ydCBjbGFzcyBOb3RFcXVhbHNEYXRlIGV4dGVuZHMgT3BlcmF0b3I8TW9tZW50PiB7XG5cbiAgICBwcm90ZWN0ZWQgZXF1YWxzOiBFcXVhbHNEYXRlO1xuXG4gICAgY29uc3RydWN0b3Iob3BlcmF0b3JzOiBPcGVyYXRvclNlcnZpY2UpIHtcbiAgICAgICAgc3VwZXIoMSk7XG4gICAgICAgIHRoaXMuZXF1YWxzID0gb3BlcmF0b3JzLmdldE9wZXJhdG9yKEVxdWFsc0RhdGUpIGFzIEVxdWFsc0RhdGU7XG4gICAgfVxuXG4gICAgY3JlYXRlUXVlcnkoZWxhc3RpY0tleXdvcmRzOiBBcnJheTxzdHJpbmc+LCBhcmdzOiBBcnJheTxNb21lbnQ+KTogUXVlcnkge1xuICAgICAgICBjb25zdCBlcXVhbHNRdWVyeSA9IHRoaXMuZXF1YWxzLmNyZWF0ZVF1ZXJ5KGVsYXN0aWNLZXl3b3JkcywgYXJncyk7XG4gICAgICAgIGlmIChlcXVhbHNRdWVyeS5pc0VtcHR5KSB7XG4gICAgICAgICAgICByZXR1cm4gZXF1YWxzUXVlcnk7XG4gICAgICAgIH1cbiAgICAgICAgcmV0dXJuIG5ldyBRdWVyeShgKCEke2VxdWFsc1F1ZXJ5LnZhbHVlfSlgKTtcbiAgICB9XG5cbiAgICBnZXRPcGVyYXRvck5hbWVUZW1wbGF0ZSgpOiBBcnJheTxzdHJpbmc+IHtcbiAgICAgICAgcmV0dXJuIFsnc2VhcmNoLm9wZXJhdG9yLm5vdEVxdWFscycsIE9wZXJhdG9yLklOUFVUX1BMQUNFSE9MREVSXTtcbiAgICB9XG5cbiAgICBzZXJpYWxpemUoKTogT3BlcmF0b3JzIHwgc3RyaW5nIHtcbiAgICAgICAgcmV0dXJuIE9wZXJhdG9ycy5OT1RfRVFVQUxTX0RBVEU7XG4gICAgfVxufVxuIl19

package/esm5/lib/search/models/operator/not-equals.js

@@ -0,0 +1,35 @@
+import { __extends } from "tslib";
+import { Operator } from './operator';
+import { Equals } from './equals';
+import { Query } from '../query/query';
+import { Operators } from './operators';
+/**
+ * Inequality operator. Will match if the field has a different value than the input.
+ * Can be used with keyword fields and different types. We don't recommend using this operator with date and datetime fields
+ * as an exact timestamp mismatch would be required.
+ * For Date needs use {@link NotEqualsDate} instead.
+ */
+var NotEquals = /** @class */ (function (_super) {
+    __extends(NotEquals, _super);
+    function NotEquals(operators) {
+        var _this = _super.call(this, 1) || this;
+        _this.equals = operators.getOperator(Equals);
+        return _this;
+    }
+    NotEquals.prototype.createQuery = function (elasticKeywords, args) {
+        var equalsQuery = this.equals.createQuery(elasticKeywords, args);
+        if (equalsQuery.isEmpty) {
+            return equalsQuery;
+        }
+        return new Query("(!" + equalsQuery.value + ")");
+    };
+    NotEquals.prototype.getOperatorNameTemplate = function () {
+        return ['search.operator.notEquals', Operator.INPUT_PLACEHOLDER];
+    };
+    NotEquals.prototype.serialize = function () {
+        return Operators.NOT_EQUALS;
+    };
+    return NotEquals;
+}(Operator));
+export { NotEquals };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/search/models/operator/operator.js

@@ -0,0 +1,134 @@
+import { Query } from '../query/query';
+import { BooleanOperator } from '../boolean-operator';
+/**
+ * Represents the low level abstraction of query generation that is responsible for the creation of queries themselves.
+ *
+ * Operators are ment to be stateless and held as singleton instances, as they can be shared without any issues.
+ * This library uses the {@link OperatorService} to store the singleton instances, but you can use your own solution,
+ * or instantiate them multiple times if you prefer.
+ *
+ * @typeparam T type of arguments this Operator can generate queries from
+ */
+var Operator = /** @class */ (function () {
+    function Operator(numberOfOperands, operatorSymbols) {
+        if (operatorSymbols === void 0) { operatorSymbols = ''; }
+        this._numberOfOperands = numberOfOperands;
+        this._operatorSymbols = operatorSymbols;
+    }
+    /**
+     * Escapes all escapable Elasticsearch symbols. Removes all unescapable Elasticsearch symbols.
+     *
+     * For a list of symbols see Elasticsearch's Query string query
+     * [doc]{@link https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-query-string-query.html#_reserved_characters}.
+     * @param input user input that should have special characters escaped
+     * @returns user input with the escapable characters escaped and the unescapable characters removed
+     */
+    Operator.escapeInput = function (input) {
+        if (typeof input === 'string') {
+            var escaped = false;
+            var output = '';
+            for (var i = 0; i < input.length; i++) {
+                if (Operator.UNESCAPABLE_CHARACTERS.has(input.charAt(i)))
+                    continue;
+                if (Operator.ESCAPABLE_CHARACTERS.has(input.charAt(i))) {
+                    output += '\\';
+                    escaped = true;
+                }
+                output += input.charAt(i);
+            }
+            return { value: output, wasEscaped: escaped };
+        }
+        return { value: input, wasEscaped: false };
+    };
+    /**
+     * Creates a Query string query string literal with the provided arguments.
+     * @param elasticKeyword Elasticsearch index keyword for the field you want to query
+     * @param arg The value that you want to query the property for
+     * @param operator The operator you want to use to query the indexed field. Consult the Elasticsearch's
+     * [documentation]{@link https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-query-string-query.html}
+     * for more information.
+     * @returns combines the input strings by this pattern: `([elasticKeyword]:[operator][arg])`
+     */
+    Operator.query = function (elasticKeyword, arg, operator) {
+        return "(" + elasticKeyword + ":" + operator + arg + ")";
+    };
+    /**
+     * Applies the provided function to all keywords and combines the resulting queries with an `OR` operator.
+     * @param elasticKeywords keywords that the function is call on
+     * @param queryConstructor function that generates a `Query` object for each keyword
+     */
+    Operator.forEachKeyword = function (elasticKeywords, queryConstructor) {
+        var simpleQueries = [];
+        elasticKeywords.forEach(function (keyword) {
+            simpleQueries.push(queryConstructor(keyword));
+        });
+        return Query.combineQueries(simpleQueries, BooleanOperator.OR);
+    };
+    /**
+     * If the value contains a space character, or if `force` is set to `true`.
+     * @param input user input that should be wrapped with double quotes
+     * @param forceWrap if set to `true` the value will be wrapped regardless of it's content
+     */
+    Operator.wrapInputWithQuotes = function (input, forceWrap) {
+        if (forceWrap === void 0) { forceWrap = false; }
+        if (typeof input === 'string' && (input.includes(' ') || forceWrap))
+            return { value: "\"" + input + "\"", wasWrapped: true };
+        else
+            return { value: input, wasWrapped: false };
+    };
+    Object.defineProperty(Operator.prototype, "numberOfOperands", {
+        /**
+         * @returns the arity of the operator.
+         */
+        get: function () {
+            return this._numberOfOperands;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Simple implementation of query generation. Will not be suitable for all Operator derivatives.
+     *
+     * Escapes the first argument from the `args` array, calls the [query()]{@link Operator#query} function for each `keyword` and combines
+     * the results with an `OR` operator.
+     * @returns query that wos constructed with the given arguments and keywords. Returns an empty query if no arguments are provided.
+     */
+    Operator.prototype.createQuery = function (elasticKeywords, args, escapeArgs) {
+        var _this = this;
+        if (escapeArgs === void 0) { escapeArgs = true; }
+        this.checkArgumentsCount(args);
+        return Operator.forEachKeyword(elasticKeywords, function (keyword) {
+            var escapedValue = escapeArgs ?
+                Operator.escapeInput(args[0]) : ({ value: args[0], wasEscaped: false });
+            var wrappedValue = Operator.wrapInputWithQuotes(escapedValue.value, escapedValue.wasEscaped);
+            var queryString = Operator.query(keyword, wrappedValue.value, _this._operatorSymbols);
+            return new Query(queryString);
+        });
+    };
+    /**
+     * Checks whether the provided array contains at leas as many arguments, as is the operators number of operands.
+     * Throws an error if not enough arguments is provided.
+     * @param args an array of potential operands
+     */
+    Operator.prototype.checkArgumentsCount = function (args) {
+        if (args.length < this.numberOfOperands) {
+            throw new Error("At least " + this.numberOfOperands + " arguments must be provided to "
+                + ("create a query with " + this.numberOfOperands + " operands!"));
+        }
+    };
+    /**
+     * Represents the placeholder "block" in operator display names.
+     */
+    Operator.INPUT_PLACEHOLDER = '';
+    /**
+     * Reserved characters for Elasticsearch queries. These characters can be escaped with a `\` character.
+     */
+    Operator.ESCAPABLE_CHARACTERS = new Set(['+', '-', '=', '&', '|', '!', '(', ')', '{', '}', '[', ']', '^', '"', '~', '*', '?', ':', '\\', '/']);
+    /**
+     * Reserved characters for Elasticsearch queries. These characters cannot be escaped and must be removed from queries.
+     */
+    Operator.UNESCAPABLE_CHARACTERS = new Set(['<', '>']);
+    return Operator;
+}());
+export { Operator };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"operator.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/search/models/operator/operator.ts"],"names":[],"mappings":"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","sourcesContent":["import {EscapeResult} from '../escape-result';\nimport {Query} from '../query/query';\nimport {BooleanOperator} from '../boolean-operator';\nimport {WrapResult} from '../wrap-result';\nimport {Operators} from './operators';\n\n/**\n * Represents the low level abstraction of query generation that is responsible for the creation of queries themselves.\n *\n * Operators are ment to be stateless and held as singleton instances, as they can be shared without any issues.\n * This library uses the {@link OperatorService} to store the singleton instances, but you can use your own solution,\n * or instantiate them multiple times if you prefer.\n *\n * @typeparam T type of arguments this Operator can generate queries from\n */\nexport abstract class Operator<T> {\n\n    /**\n     * Represents the placeholder \"block\" in operator display names.\n     */\n    public static readonly INPUT_PLACEHOLDER = '';\n\n    /**\n     * Reserved characters for Elasticsearch queries. These characters can be escaped with a `\\` character.\n     */\n    private static readonly ESCAPABLE_CHARACTERS = new Set(\n        ['+', '-', '=', '&', '|', '!', '(', ')', '{', '}', '[', ']', '^', '\"', '~', '*', '?', ':', '\\\\', '/']);\n\n    /**\n     * Reserved characters for Elasticsearch queries. These characters cannot be escaped and must be removed from queries.\n     */\n    private static readonly UNESCAPABLE_CHARACTERS = new Set(['<', '>']);\n\n    /**\n     * Determines the arity of the operator, that is the number of arguments/operands it takes.\n     */\n    private readonly _numberOfOperands: number;\n\n    /**\n     * The operator symbol that is used to generate the query.\n     */\n    private readonly _operatorSymbols: string;\n\n    protected constructor(numberOfOperands: number, operatorSymbols = '') {\n        this._numberOfOperands = numberOfOperands;\n        this._operatorSymbols = operatorSymbols;\n    }\n\n    /**\n     * Escapes all escapable Elasticsearch symbols. Removes all unescapable Elasticsearch symbols.\n     *\n     * For a list of symbols see Elasticsearch's Query string query\n     * [doc]{@link https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-query-string-query.html#_reserved_characters}.\n     * @param input user input that should have special characters escaped\n     * @returns user input with the escapable characters escaped and the unescapable characters removed\n     */\n    public static escapeInput(input: string): EscapeResult {\n        if (typeof input === 'string') {\n            let escaped = false;\n            let output = '';\n            for (let i = 0; i < input.length; i++) {\n                if (Operator.UNESCAPABLE_CHARACTERS.has(input.charAt(i)))\n                    continue;\n                if (Operator.ESCAPABLE_CHARACTERS.has(input.charAt(i))) {\n                    output += '\\\\';\n                    escaped = true;\n                }\n                output += input.charAt(i);\n            }\n            return {value: output, wasEscaped: escaped};\n        }\n        return {value: input, wasEscaped: false};\n    }\n\n    /**\n     * Creates a Query string query string literal with the provided arguments.\n     * @param elasticKeyword Elasticsearch index keyword for the field you want to query\n     * @param arg The value that you want to query the property for\n     * @param operator The operator you want to use to query the indexed field. Consult the Elasticsearch's\n     * [documentation]{@link https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-query-string-query.html}\n     * for more information.\n     * @returns combines the input strings by this pattern: `([elasticKeyword]:[operator][arg])`\n     */\n    public static query(elasticKeyword: string, arg: string, operator: string): string {\n        return `(${elasticKeyword}:${operator}${arg})`;\n    }\n\n    /**\n     * Applies the provided function to all keywords and combines the resulting queries with an `OR` operator.\n     * @param elasticKeywords keywords that the function is call on\n     * @param queryConstructor function that generates a `Query` object for each keyword\n     */\n    public static forEachKeyword(elasticKeywords: Array<string>, queryConstructor: (keyword: string) => Query): Query {\n        const simpleQueries = [];\n        elasticKeywords.forEach(keyword => {\n            simpleQueries.push(queryConstructor(keyword));\n        });\n        return Query.combineQueries(simpleQueries, BooleanOperator.OR);\n    }\n\n    /**\n     * If the value contains a space character, or if `force` is set to `true`.\n     * @param input user input that should be wrapped with double quotes\n     * @param forceWrap if set to `true` the value will be wrapped regardless of it's content\n     */\n    public static wrapInputWithQuotes(input: string, forceWrap = false): WrapResult {\n        if (typeof input === 'string' && (input.includes(' ') || forceWrap))\n            return {value: `\"${input}\"`, wasWrapped: true};\n        else\n            return {value: input, wasWrapped: false};\n    }\n\n    /**\n     * @returns the arity of the operator.\n     */\n    public get numberOfOperands(): number {\n        return this._numberOfOperands;\n    }\n\n    /**\n     * Simple implementation of query generation. Will not be suitable for all Operator derivatives.\n     *\n     * Escapes the first argument from the `args` array, calls the [query()]{@link Operator#query} function for each `keyword` and combines\n     * the results with an `OR` operator.\n     * @returns query that wos constructed with the given arguments and keywords. Returns an empty query if no arguments are provided.\n     */\n    public createQuery(elasticKeywords: Array<string>, args: Array<T>, escapeArgs = true): Query {\n        this.checkArgumentsCount(args);\n        return Operator.forEachKeyword(elasticKeywords, (keyword: string) => {\n            const escapedValue = escapeArgs ?\n                Operator.escapeInput(args[0] as unknown as string) : ({value: args[0] as unknown as string, wasEscaped: false});\n            const wrappedValue = Operator.wrapInputWithQuotes(escapedValue.value, escapedValue.wasEscaped);\n            const queryString = Operator.query(keyword, wrappedValue.value, this._operatorSymbols);\n            return new Query(queryString);\n        });\n    }\n\n    /**\n     * The name template is used when generating search GUI, and so the arity of the operator should match the number of\n     * {@link INPUT_PLACEHOLDER} constant occurrences in the returned array.\n     *\n     * @returns an array of translation paths that represent the operator name, as it should be displayed to the user.\n     * The {@link INPUT_PLACEHOLDER} constant (or any falsy value) can be used to place visual input placeholder blocks in the\n     * operator name where user input is expected.\n     */\n    public abstract getOperatorNameTemplate(): Array<string>;\n\n    /**\n     * @returns the operator class in a serializable form\n     */\n    public abstract serialize(): Operators | string;\n\n    /**\n     * Checks whether the provided array contains at leas as many arguments, as is the operators number of operands.\n     * Throws an error if not enough arguments is provided.\n     * @param args an array of potential operands\n     */\n    protected checkArgumentsCount(args: Array<any>): void {\n        if (args.length < this.numberOfOperands) {\n            throw new Error(`At least ${this.numberOfOperands} arguments must be provided to `\n                + `create a query with ${this.numberOfOperands} operands!`);\n        }\n    }\n}\n"]}