@netgrif/components-core 6.0.1

package/esm2015/lib/search/models/datafield-map-key.js

@@ -0,0 +1,69 @@
+/**
+ * Objects that represent keys to the map of available data fields in {@link CaseDataset} search category.
+ *
+ * Since javascript maps don't support objects as keys this class has a serialized form, that is used as a `string` key.
+ *
+ * This class also acts as an autocomplete option when the target datafield is selected. The real data fields are then extracted from the
+ * map to which this object is a key.
+ */
+export class DatafieldMapKey {
+    constructor(_inputType, _title) {
+        this._inputType = _inputType;
+        this._title = _title;
+    }
+    static serializedForm(type, title) {
+        return `${type}#${title}`;
+    }
+    static parse(serializedMapKey) {
+        const parts = serializedMapKey.split('#');
+        return new DatafieldMapKey(parts.shift(), parts.join('#'));
+    }
+    get title() {
+        return this._title;
+    }
+    get type() {
+        return this._inputType;
+    }
+    get icon() {
+        switch (this._inputType) {
+            case 'boolean':
+                return 'toggle_off';
+            case 'date':
+                return 'today';
+            case 'enumeration':
+                return 'radio_button_checked';
+            case 'file':
+                return 'insert_drive_file';
+            case 'fileList':
+                return 'file_copy';
+            case 'multichoice':
+                return 'check_box';
+            case 'number':
+                return 'looks_one';
+            case 'user':
+                return 'person';
+            case 'userList':
+                return 'people';
+            case 'dateTime':
+                return 'schedule';
+            default:
+                return 'text_format';
+        }
+    }
+    /**
+     * Alias for [toSerializedForm()]{@link DatafieldMapKey#toSerializedForm}
+     */
+    get value() {
+        return this.toSerializedForm();
+    }
+    /**
+     * Alias for [title]{@link DatafieldMapKey#title}
+     */
+    get text() {
+        return this.title;
+    }
+    toSerializedForm() {
+        return DatafieldMapKey.serializedForm(this._inputType, this._title);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/search/models/escape-result.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXNjYXBlLXJlc3VsdC5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi9zZWFyY2gvbW9kZWxzL2VzY2FwZS1yZXN1bHQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogUmVzdWx0IGZyb20gdGhlIFtlc2NhcGVJbnB1dCgpXXtAbGluayBPcGVyYXRvciNlc2NhcGVJbnB1dH0gZnVuY3Rpb24uXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgRXNjYXBlUmVzdWx0IHtcbiAgICAvKipcbiAgICAgKiBUaGUgZXNjYXBlZCB2YWx1ZS5cbiAgICAgKi9cbiAgICB2YWx1ZTogc3RyaW5nO1xuXG4gICAgLyoqXG4gICAgICogV2hldGhlciBzb21lIGNoYXJhY3RlcnMgaGFkIGJlZW4gZXNjYXBlZCBvciBub3QuXG4gICAgICovXG4gICAgd2FzRXNjYXBlZDogYm9vbGVhbjtcbn1cbiJdfQ==

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

@@ -0,0 +1,26 @@
+import { InRangeDateTime } from './in-range-date-time';
+import { Operator } from './operator';
+import { Operators } from './operators';
+/**
+ * Equality operator for indexed fields that store a date time object in timestamp format.
+ *
+ * Will create a range query that matches every timestamp from the 0th millisecond of the selected date time object (included)
+ * to the 0th millisecond after of the next minute after the minute of the date time object (excluded).
+ */
+export class EqualsDateTime extends Operator {
+    constructor(operators) {
+        super(1);
+        this.dateTimeRange = operators.getOperator(InRangeDateTime);
+    }
+    createQuery(elasticKeywords, args) {
+        this.checkArgumentsCount(args);
+        return this.dateTimeRange.createQuery(elasticKeywords, [args[0], args[0]]);
+    }
+    getOperatorNameTemplate() {
+        return ['search.operator.equals', Operator.INPUT_PLACEHOLDER];
+    }
+    serialize() {
+        return Operators.EQUALS_DATE_TIME;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/search/models/operator/equals-date.js

@@ -0,0 +1,26 @@
+import { Operator } from './operator';
+import { InRangeDate } from './in-range-date';
+import { Operators } from './operators';
+/**
+ * Equality operator for indexed fields that store a date in timestamp format.
+ *
+ * Will create a range query that matches every timestamp from the midnight of the selected day (included)
+ * to the midnight of the next day (excluded).
+ */
+export class EqualsDate extends Operator {
+    constructor(operators) {
+        super(1);
+        this.dateRange = operators.getOperator(InRangeDate);
+    }
+    createQuery(elasticKeywords, args) {
+        this.checkArgumentsCount(args);
+        return this.dateRange.createQuery(elasticKeywords, [args[0], args[0]]);
+    }
+    getOperatorNameTemplate() {
+        return ['search.operator.equals', Operator.INPUT_PLACEHOLDER];
+    }
+    serialize() {
+        return Operators.EQUALS_DATE;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/search/models/operator/equals.js

@@ -0,0 +1,21 @@
+import { Operator } from './operator';
+import { Operators } from './operators';
+/**
+ * Strict equality operator. Will match if the field has the exact same value as the input.
+ * Can be used with keyword fields and different types,
+ * but it is not recommended to use it with date and datetime fields as an exact timestamp match would be required.
+ * For timestamps use {@link EqualsDate} or {@link EqualsDateTime} instead.
+ */
+export class Equals extends Operator {
+    constructor() {
+        // query string queries don't use a special symbol for strict equality
+        super(1, '');
+    }
+    getOperatorNameTemplate() {
+        return ['search.operator.equals', Operator.INPUT_PLACEHOLDER];
+    }
+    serialize() {
+        return Operators.EQUALS;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXF1YWxzLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3NlYXJjaC9tb2RlbHMvb3BlcmF0b3IvZXF1YWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxRQUFRLEVBQUMsTUFBTSxZQUFZLENBQUM7QUFDcEMsT0FBTyxFQUFDLFNBQVMsRUFBQyxNQUFNLGFBQWEsQ0FBQztBQUV0Qzs7Ozs7R0FLRztBQUNILE1BQU0sT0FBTyxNQUFPLFNBQVEsUUFBeUI7SUFDakQ7UUFDSSxzRUFBc0U7UUFDdEUsS0FBSyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQztJQUNqQixDQUFDO0lBRUQsdUJBQXVCO1FBQ25CLE9BQU8sQ0FBQyx3QkFBd0IsRUFBRSxRQUFRLENBQUMsaUJBQWlCLENBQUMsQ0FBQztJQUNsRSxDQUFDO0lBRUQsU0FBUztRQUNMLE9BQU8sU0FBUyxDQUFDLE1BQU0sQ0FBQztJQUM1QixDQUFDO0NBQ0oiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge09wZXJhdG9yfSBmcm9tICcuL29wZXJhdG9yJztcbmltcG9ydCB7T3BlcmF0b3JzfSBmcm9tICcuL29wZXJhdG9ycyc7XG5cbi8qKlxuICogU3RyaWN0IGVxdWFsaXR5IG9wZXJhdG9yLiBXaWxsIG1hdGNoIGlmIHRoZSBmaWVsZCBoYXMgdGhlIGV4YWN0IHNhbWUgdmFsdWUgYXMgdGhlIGlucHV0LlxuICogQ2FuIGJlIHVzZWQgd2l0aCBrZXl3b3JkIGZpZWxkcyBhbmQgZGlmZmVyZW50IHR5cGVzLFxuICogYnV0IGl0IGlzIG5vdCByZWNvbW1lbmRlZCB0byB1c2UgaXQgd2l0aCBkYXRlIGFuZCBkYXRldGltZSBmaWVsZHMgYXMgYW4gZXhhY3QgdGltZXN0YW1wIG1hdGNoIHdvdWxkIGJlIHJlcXVpcmVkLlxuICogRm9yIHRpbWVzdGFtcHMgdXNlIHtAbGluayBFcXVhbHNEYXRlfSBvciB7QGxpbmsgRXF1YWxzRGF0ZVRpbWV9IGluc3RlYWQuXG4gKi9cbmV4cG9ydCBjbGFzcyBFcXVhbHMgZXh0ZW5kcyBPcGVyYXRvcjxzdHJpbmcgfCBudW1iZXI+IHtcbiAgICBjb25zdHJ1Y3RvcigpIHtcbiAgICAgICAgLy8gcXVlcnkgc3RyaW5nIHF1ZXJpZXMgZG9uJ3QgdXNlIGEgc3BlY2lhbCBzeW1ib2wgZm9yIHN0cmljdCBlcXVhbGl0eVxuICAgICAgICBzdXBlcigxLCAnJyk7XG4gICAgfVxuXG4gICAgZ2V0T3BlcmF0b3JOYW1lVGVtcGxhdGUoKTogQXJyYXk8c3RyaW5nPiB7XG4gICAgICAgIHJldHVybiBbJ3NlYXJjaC5vcGVyYXRvci5lcXVhbHMnLCBPcGVyYXRvci5JTlBVVF9QTEFDRUhPTERFUl07XG4gICAgfVxuXG4gICAgc2VyaWFsaXplKCk6IE9wZXJhdG9ycyB8IHN0cmluZyB7XG4gICAgICAgIHJldHVybiBPcGVyYXRvcnMuRVFVQUxTO1xuICAgIH1cbn1cbiJdfQ==

package/esm2015/lib/search/models/operator/in-range-date-time.js

@@ -0,0 +1,43 @@
+import { Operator } from './operator';
+import moment from 'moment';
+import { Query } from '../query/query';
+import { Operators } from './operators';
+/**
+ * Range operator for indexed fields that store a date time in timestamp format.
+ *
+ * Will create a range query that matches every timestamp from the 0th millisecond of the first date time object (included)
+ * to the 0th millisecond of the next minute after the minute in the second date time object (excluded).
+ */
+export class InRangeDateTime extends Operator {
+    constructor() {
+        super(2);
+    }
+    /**
+     * Creates a query as specified by the [classes]{@link InRangeDate} documentation.
+     * See [super.createQuery()]{@link Operator#createQuery} for more information.
+     * @param elasticKeywords keywords of the fields that should be queried.
+     * If more than one is provided then queries for every keyword will be generated and combined with an OR operator.
+     * @param args start and end date for the range. If you want to ignore the time information use {@link InRangeDate}
+     * Operator instead. The two date time objects must be in ascending order, if not the behavior is undefined.
+     */
+    createQuery(elasticKeywords, args) {
+        this.checkArgumentsCount(args);
+        const arg1 = moment(args[0]);
+        arg1.milliseconds(0);
+        arg1.seconds(0);
+        const arg2 = moment(args[1]);
+        arg2.milliseconds(0);
+        arg2.seconds(0);
+        arg2.minutes(arg2.minutes() + 1); // moment handles rollover
+        return Operator.forEachKeyword(elasticKeywords, (keyword) => {
+            return new Query(`(${keyword}:[${arg1.valueOf()} TO ${arg2.valueOf()}})`);
+        });
+    }
+    getOperatorNameTemplate() {
+        return ['search.operator.inRange.from', Operator.INPUT_PLACEHOLDER, 'search.operator.inRange.to', Operator.INPUT_PLACEHOLDER];
+    }
+    serialize() {
+        return Operators.IN_RANGE_DATE_TIME;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/search/models/operator/in-range-date.js

@@ -0,0 +1,42 @@
+import { Operator } from './operator';
+import { Query } from '../query/query';
+import moment from 'moment';
+import { clearTimeInformation } from '../../../utility/clear-time-information';
+import { Operators } from './operators';
+/**
+ * Range operator for indexed fields that store a date in timestamp format.
+ *
+ * Will create a range query that matches every timestamp from the midnight of the first day (included)
+ * to the midnight of the day after the second day (excluded).
+ */
+export class InRangeDate extends Operator {
+    constructor() {
+        super(2);
+    }
+    /**
+     * Creates a query as specified by the [classes]{@link InRangeDate} documentation.
+     * See [super.createQuery()]{@link Operator#createQuery} for more information.
+     * @param elasticKeywords keywords of the fields that should be queried.
+     * If more than one is provided then queries for every keyword will be generated and combined with an OR operator.
+     * @param args start and end date for the range. Any time information will be ignored use {@link InRangeDateTime}
+     * if you want a date time query instead. The two dates must be in ascending order, if not the behavior is undefined.
+     */
+    createQuery(elasticKeywords, args) {
+        this.checkArgumentsCount(args);
+        const arg1 = moment(args[0]);
+        clearTimeInformation(arg1);
+        const arg2 = moment(args[1]);
+        clearTimeInformation(arg2);
+        arg2.date(arg2.date() + 1); // moment handles rollover
+        return Operator.forEachKeyword(elasticKeywords, (keyword) => {
+            return new Query(`(${keyword}:[${arg1.valueOf()} TO ${arg2.valueOf()}})`);
+        });
+    }
+    getOperatorNameTemplate() {
+        return ['search.operator.inRange.from', Operator.INPUT_PLACEHOLDER, 'search.operator.inRange.to', Operator.INPUT_PLACEHOLDER];
+    }
+    serialize() {
+        return Operators.IN_RANGE_DATE;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/search/models/operator/in-range.js

@@ -0,0 +1,22 @@
+import { Operator } from './operator';
+import { Query } from '../query/query';
+import { Operators } from './operators';
+/**
+ * A range operator for numeric fields, with closed interval on both sides of the range.
+ */
+export class InRange extends Operator {
+    constructor() {
+        super(2);
+    }
+    createQuery(elasticKeywords, args) {
+        this.checkArgumentsCount(args);
+        return Operator.forEachKeyword(elasticKeywords, keyword => new Query(`(${keyword}:[${args[0]} TO ${args[1]}])`));
+    }
+    getOperatorNameTemplate() {
+        return ['search.operator.inRange.from', Operator.INPUT_PLACEHOLDER, 'search.operator.inRange.to', Operator.INPUT_PLACEHOLDER];
+    }
+    serialize() {
+        return Operators.IN_RANGE;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/search/models/operator/is-null.js

@@ -0,0 +1,69 @@
+import { Operator } from './operator';
+import { Query } from '../query/query';
+import { Operators } from './operators';
+/**
+ * An operator that can be used on any field and matches entries with null or empty string values.
+ *
+ * Beware that if any additional constraints should be applied to the generated query the results may behave strangely.
+ * Consult the [createQueryWithConstraint()]{@link IsNull#createQueryWithConstraint} method for more information.
+ */
+export class IsNull extends Operator {
+    constructor() {
+        super(0);
+    }
+    /**
+     * @param elasticKeywords the queried fields
+     * @returns Generates a query that matches null fields and fields with empty string values.
+     */
+    createQuery(elasticKeywords) {
+        return Operator.forEachKeyword(elasticKeywords, keyword => new Query(`(${this.nullQueryString(keyword)}OR${this.emptyStringQueryString(keyword)})`));
+    }
+    /**
+     * Counterintuitively elasticsearch query string queries behave weirdly when combining the queries with operators such as `AND`.
+     * Because of this the following query:
+     *
+     *    (dataSet.text_0.value:"")
+     *
+     * returns an empty result set.
+     *
+     * But query that should be intuitively more constraining:
+     *
+     *     (dataSet.text_0.value:"") AND (processId:600168ccf68fea5241ae5e62)
+     *
+     * will return a non empty and expected result.
+     *
+     * This method exists to combat this issue and add the, sometimes necessary, constraint into the query generated by this operator.
+     *
+     * @param elasticKeywords the queried fields
+     * @param constraint a constraining query that is distributively applied into the query generated by this operator.
+     * If an empty query is provided the result will be the same as calling [createQuery()]{@link IsNull#createQuery}.
+     * @returns a query with distributively applied constraint query
+     */
+    createQueryWithConstraint(elasticKeywords, constraint) {
+        if (constraint.isEmpty) {
+            return this.createQuery(elasticKeywords);
+        }
+        return Operator.forEachKeyword(elasticKeywords, keyword => new Query(`((${this.nullQueryString(keyword)}AND${constraint.value})OR(${this.emptyStringQueryString(keyword)}AND${constraint.value}))`));
+    }
+    /**
+     * @param elasticKeyword the queried field
+     * @returns a string representation of the query that checks whether the field is null
+     */
+    nullQueryString(elasticKeyword) {
+        return `(!(_exists_:${elasticKeyword}))`;
+    }
+    /**
+     * @param elasticKeyword the queried field
+     * @returns a string representation of the query that checks whether the field has an empty string value
+     */
+    emptyStringQueryString(elasticKeyword) {
+        return `(${elasticKeyword}:"")`;
+    }
+    getOperatorNameTemplate() {
+        return ['search.operator.isNull'];
+    }
+    serialize() {
+        return Operators.IS_NULL;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/search/models/operator/less-than-date-time.js

@@ -0,0 +1,27 @@
+import { Operator } from './operator';
+import moment from 'moment';
+import { LessThan } from './less-than';
+import { Operators } from './operators';
+/**
+ * A strict less than operator for DateTime fields
+ */
+export class LessThanDateTime extends Operator {
+    constructor(operators) {
+        super(1);
+        this.lessThan = operators.getOperator(LessThan);
+    }
+    createQuery(elasticKeywords, args) {
+        this.checkArgumentsCount(args);
+        const arg = moment(args[0]);
+        arg.milliseconds(0);
+        arg.seconds(0);
+        return this.lessThan.createQuery(elasticKeywords, [arg.valueOf()]);
+    }
+    getOperatorNameTemplate() {
+        return ['search.operator.lessThan', Operator.INPUT_PLACEHOLDER];
+    }
+    serialize() {
+        return Operators.LESS_THAN_DATE_TIME;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,27 @@
+import { Operator } from './operator';
+import moment from 'moment';
+import { clearTimeInformation } from '../../../utility/clear-time-information';
+import { LessThan } from './less-than';
+import { Operators } from './operators';
+/**
+ * A strict less than operator for Date fields
+ */
+export class LessThanDate extends Operator {
+    constructor(operators) {
+        super(1);
+        this.lessThan = operators.getOperator(LessThan);
+    }
+    createQuery(elasticKeywords, args) {
+        this.checkArgumentsCount(args);
+        const arg = moment(args[0]);
+        clearTimeInformation(arg);
+        return this.lessThan.createQuery(elasticKeywords, [arg.valueOf()]);
+    }
+    getOperatorNameTemplate() {
+        return ['search.operator.lessThan', Operator.INPUT_PLACEHOLDER];
+    }
+    serialize() {
+        return Operators.LESS_THAN_DATE;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,27 @@
+import { Operator } from './operator';
+import moment from 'moment';
+import { LessThanEqual } from './less-than-equal';
+import { Operators } from './operators';
+/**
+ * Greater or equal than operator for Datetime fields
+ */
+export class LessThanEqualDateTime extends Operator {
+    constructor(operators) {
+        super(1);
+        this.lessThanEqual = operators.getOperator(LessThanEqual);
+    }
+    createQuery(elasticKeywords, args) {
+        this.checkArgumentsCount(args);
+        const arg = moment(args[0]);
+        arg.milliseconds(0);
+        arg.seconds(0);
+        return this.lessThanEqual.createQuery(elasticKeywords, [arg.valueOf()]);
+    }
+    getOperatorNameTemplate() {
+        return ['search.operator.lessThanEqual', Operator.INPUT_PLACEHOLDER];
+    }
+    serialize() {
+        return Operators.LESS_THAN_DATE_TIME;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,26 @@
+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
+ */
+export class LessThanEqualDate extends Operator {
+    constructor(operators) {
+        super(1);
+        this.lessThan = operators.getOperator(LessThanDate);
+    }
+    createQuery(elasticKeywords, args) {
+        this.checkArgumentsCount(args);
+        const arg = moment(args[0]);
+        arg.date(arg.date() + 1);
+        return this.lessThan.createQuery(elasticKeywords, [arg]);
+    }
+    getOperatorNameTemplate() {
+        return ['search.operator.lessThanEqual', Operator.INPUT_PLACEHOLDER];
+    }
+    serialize() {
+        return Operators.LESS_THAN_EQUAL_DATE;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,17 @@
+import { Operator } from './operator';
+import { Operators } from './operators';
+/**
+ * Less or equal than operator for numeric fields
+ */
+export class LessThanEqual extends Operator {
+    constructor() {
+        super(1, '<=');
+    }
+    getOperatorNameTemplate() {
+        return ['search.operator.lessThanEqual', Operator.INPUT_PLACEHOLDER];
+    }
+    serialize() {
+        return Operators.LESS_THAN_EQUAL;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGVzcy10aGFuLWVxdWFsLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3NlYXJjaC9tb2RlbHMvb3BlcmF0b3IvbGVzcy10aGFuLWVxdWFsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxRQUFRLEVBQUMsTUFBTSxZQUFZLENBQUM7QUFDcEMsT0FBTyxFQUFDLFNBQVMsRUFBQyxNQUFNLGFBQWEsQ0FBQztBQUV0Qzs7R0FFRztBQUNILE1BQU0sT0FBTyxhQUFjLFNBQVEsUUFBZ0I7SUFFL0M7UUFDSSxLQUFLLENBQUMsQ0FBQyxFQUFFLElBQUksQ0FBQyxDQUFDO0lBQ25CLENBQUM7SUFFRCx1QkFBdUI7UUFDbkIsT0FBTyxDQUFDLCtCQUErQixFQUFFLFFBQVEsQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO0lBQ3pFLENBQUM7SUFFRCxTQUFTO1FBQ0wsT0FBTyxTQUFTLENBQUMsZUFBZSxDQUFDO0lBQ3JDLENBQUM7Q0FHSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7T3BlcmF0b3J9IGZyb20gJy4vb3BlcmF0b3InO1xuaW1wb3J0IHtPcGVyYXRvcnN9IGZyb20gJy4vb3BlcmF0b3JzJztcblxuLyoqXG4gKiBMZXNzIG9yIGVxdWFsIHRoYW4gb3BlcmF0b3IgZm9yIG51bWVyaWMgZmllbGRzXG4gKi9cbmV4cG9ydCBjbGFzcyBMZXNzVGhhbkVxdWFsIGV4dGVuZHMgT3BlcmF0b3I8bnVtYmVyPiB7XG5cbiAgICBjb25zdHJ1Y3RvcigpIHtcbiAgICAgICAgc3VwZXIoMSwgJzw9Jyk7XG4gICAgfVxuXG4gICAgZ2V0T3BlcmF0b3JOYW1lVGVtcGxhdGUoKTogQXJyYXk8c3RyaW5nPiB7XG4gICAgICAgIHJldHVybiBbJ3NlYXJjaC5vcGVyYXRvci5sZXNzVGhhbkVxdWFsJywgT3BlcmF0b3IuSU5QVVRfUExBQ0VIT0xERVJdO1xuICAgIH1cblxuICAgIHNlcmlhbGl6ZSgpOiBPcGVyYXRvcnMgfCBzdHJpbmcge1xuICAgICAgICByZXR1cm4gT3BlcmF0b3JzLkxFU1NfVEhBTl9FUVVBTDtcbiAgICB9XG5cblxufVxuIl19

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

@@ -0,0 +1,17 @@
+import { Operator } from './operator';
+import { Operators } from './operators';
+/**
+ * A strict less than operator for numeric fields.
+ */
+export class LessThan extends Operator {
+    constructor() {
+        super(1, '<');
+    }
+    getOperatorNameTemplate() {
+        return ['search.operator.lessThan', Operator.INPUT_PLACEHOLDER];
+    }
+    serialize() {
+        return Operators.LESS_THAN;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGVzcy10aGFuLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3NlYXJjaC9tb2RlbHMvb3BlcmF0b3IvbGVzcy10aGFuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxRQUFRLEVBQUMsTUFBTSxZQUFZLENBQUM7QUFDcEMsT0FBTyxFQUFDLFNBQVMsRUFBQyxNQUFNLGFBQWEsQ0FBQztBQUV0Qzs7R0FFRztBQUNILE1BQU0sT0FBTyxRQUFTLFNBQVEsUUFBZ0I7SUFDMUM7UUFDSSxLQUFLLENBQUMsQ0FBQyxFQUFFLEdBQUcsQ0FBQyxDQUFDO0lBQ2xCLENBQUM7SUFFRCx1QkFBdUI7UUFDbkIsT0FBTyxDQUFDLDBCQUEwQixFQUFFLFFBQVEsQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO0lBQ3BFLENBQUM7SUFFRCxTQUFTO1FBQ0wsT0FBTyxTQUFTLENBQUMsU0FBUyxDQUFDO0lBQy9CLENBQUM7Q0FDSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7T3BlcmF0b3J9IGZyb20gJy4vb3BlcmF0b3InO1xuaW1wb3J0IHtPcGVyYXRvcnN9IGZyb20gJy4vb3BlcmF0b3JzJztcblxuLyoqXG4gKiBBIHN0cmljdCBsZXNzIHRoYW4gb3BlcmF0b3IgZm9yIG51bWVyaWMgZmllbGRzLlxuICovXG5leHBvcnQgY2xhc3MgTGVzc1RoYW4gZXh0ZW5kcyBPcGVyYXRvcjxudW1iZXI+IHtcbiAgICBjb25zdHJ1Y3RvcigpIHtcbiAgICAgICAgc3VwZXIoMSwgJzwnKTtcbiAgICB9XG5cbiAgICBnZXRPcGVyYXRvck5hbWVUZW1wbGF0ZSgpOiBBcnJheTxzdHJpbmc+IHtcbiAgICAgICAgcmV0dXJuIFsnc2VhcmNoLm9wZXJhdG9yLmxlc3NUaGFuJywgT3BlcmF0b3IuSU5QVVRfUExBQ0VIT0xERVJdO1xuICAgIH1cblxuICAgIHNlcmlhbGl6ZSgpOiBPcGVyYXRvcnMgfCBzdHJpbmcge1xuICAgICAgICByZXR1cm4gT3BlcmF0b3JzLkxFU1NfVEhBTjtcbiAgICB9XG59XG4iXX0=

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

@@ -0,0 +1,29 @@
+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.
+ */
+export class Like extends Operator {
+    constructor() {
+        super(1);
+    }
+    createQuery(elasticKeywords, args) {
+        this.checkArgumentsCount(args);
+        const escaped = Operator.escapeInput(args[0]);
+        return Operator.forEachKeyword(elasticKeywords, keyword => escaped.wasEscaped ? new Query(`(${keyword}:${escaped.value})`) : new Query(`(${keyword}:${escaped.value}~)`));
+    }
+    getOperatorNameTemplate() {
+        return ['search.operator.like', Operator.INPUT_PLACEHOLDER];
+    }
+    serialize() {
+        return Operators.LIKE;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlrZS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi9zZWFyY2gvbW9kZWxzL29wZXJhdG9yL2xpa2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFFBQVEsRUFBQyxNQUFNLFlBQVksQ0FBQztBQUNwQyxPQUFPLEVBQUMsS0FBSyxFQUFDLE1BQU0sZ0JBQWdCLENBQUM7QUFDckMsT0FBTyxFQUFDLFNBQVMsRUFBQyxNQUFNLGFBQWEsQ0FBQztBQUV0Qzs7Ozs7Ozs7R0FRRztBQUNILE1BQU0sT0FBTyxJQUFLLFNBQVEsUUFBZ0I7SUFDdEM7UUFDSSxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDYixDQUFDO0lBRUQsV0FBVyxDQUFDLGVBQThCLEVBQUUsSUFBbUI7UUFDM0QsSUFBSSxDQUFDLG1CQUFtQixDQUFDLElBQUksQ0FBQyxDQUFDO1FBQy9CLE1BQU0sT0FBTyxHQUFHLFFBQVEsQ0FBQyxXQUFXLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFDOUMsT0FBTyxRQUFRLENBQUMsY0FBYyxDQUFDLGVBQWUsRUFDMUMsT0FBTyxDQUFDLEVBQUUsQ0FBQyxPQUFPLENBQUMsVUFBVSxDQUFDLENBQUMsQ0FBQyxJQUFJLEtBQUssQ0FBQyxJQUFJLE9BQU8sSUFBSSxPQUFPLENBQUMsS0FBSyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxLQUFLLENBQUMsSUFBSSxPQUFPLElBQUksT0FBTyxDQUFDLEtBQUssSUFBSSxDQUFDLENBQUMsQ0FBQztJQUNsSSxDQUFDO0lBRUQsdUJBQXVCO1FBQ25CLE9BQU8sQ0FBQyxzQkFBc0IsRUFBRSxRQUFRLENBQUMsaUJBQWlCLENBQUMsQ0FBQztJQUNoRSxDQUFDO0lBRUQsU0FBUztRQUNMLE9BQU8sU0FBUyxDQUFDLElBQUksQ0FBQztJQUMxQixDQUFDO0NBQ0oiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge09wZXJhdG9yfSBmcm9tICcuL29wZXJhdG9yJztcbmltcG9ydCB7UXVlcnl9IGZyb20gJy4uL3F1ZXJ5L3F1ZXJ5JztcbmltcG9ydCB7T3BlcmF0b3JzfSBmcm9tICcuL29wZXJhdG9ycyc7XG5cbi8qKlxuICogQSBmdXp6eSBzZWFyY2ggb3BlcmF0b3IgZm9yIHN0cmluZyBmaWVsZHMuXG4gKlxuICogQmVoYXZlcyBkaWZmZXJlbnRseSBmb3Igc3RyaW5ncyB3aXRoIHNwYWNlcyBhbmQgd2l0aG91dC5cbiAqIFdpdGggc3BhY2VzIHNlYXJjaGVzIGZvciBtYXRjaGVzIGNvbnRhaW5pbmcgdGhlIHRva2VuaXplZCBzdHJpbmdzLlxuICogV2l0aG91dCBzcGFjZXMgc2VhcmNoZXMgZm9yIHN0cmluZ3Mgd2l0aGluIHRoZSBkZWZhdWx0IGVkaXQgZGlzdGFuY2UuXG4gKiBTZWUgW2RvY3Nde0BsaW5rIGh0dHBzOi8vd3d3LmVsYXN0aWMuY28vZ3VpZGUvZW4vZWxhc3RpY3NlYXJjaC9yZWZlcmVuY2UvNi42L3F1ZXJ5LWRzbC1xdWVyeS1zdHJpbmctcXVlcnkuaHRtbCNfZnV6emluZXNzfVxuICogZm9yIG1vcmUgaW5mb3JtYXRpb24uXG4gKi9cbmV4cG9ydCBjbGFzcyBMaWtlIGV4dGVuZHMgT3BlcmF0b3I8c3RyaW5nPiB7XG4gICAgY29uc3RydWN0b3IoKSB7XG4gICAgICAgIHN1cGVyKDEpO1xuICAgIH1cblxuICAgIGNyZWF0ZVF1ZXJ5KGVsYXN0aWNLZXl3b3JkczogQXJyYXk8c3RyaW5nPiwgYXJnczogQXJyYXk8c3RyaW5nPik6IFF1ZXJ5IHtcbiAgICAgICAgdGhpcy5jaGVja0FyZ3VtZW50c0NvdW50KGFyZ3MpO1xuICAgICAgICBjb25zdCBlc2NhcGVkID0gT3BlcmF0b3IuZXNjYXBlSW5wdXQoYXJnc1swXSk7XG4gICAgICAgIHJldHVybiBPcGVyYXRvci5mb3JFYWNoS2V5d29yZChlbGFzdGljS2V5d29yZHMsXG4gICAgICAgICAgICBrZXl3b3JkID0+IGVzY2FwZWQud2FzRXNjYXBlZCA/IG5ldyBRdWVyeShgKCR7a2V5d29yZH06JHtlc2NhcGVkLnZhbHVlfSlgKSA6IG5ldyBRdWVyeShgKCR7a2V5d29yZH06JHtlc2NhcGVkLnZhbHVlfX4pYCkpO1xuICAgIH1cblxuICAgIGdldE9wZXJhdG9yTmFtZVRlbXBsYXRlKCk6IEFycmF5PHN0cmluZz4ge1xuICAgICAgICByZXR1cm4gWydzZWFyY2gub3BlcmF0b3IubGlrZScsIE9wZXJhdG9yLklOUFVUX1BMQUNFSE9MREVSXTtcbiAgICB9XG5cbiAgICBzZXJpYWxpemUoKTogT3BlcmF0b3JzIHwgc3RyaW5nIHtcbiAgICAgICAgcmV0dXJuIE9wZXJhdG9ycy5MSUtFO1xuICAgIH1cbn1cbiJdfQ==

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

@@ -0,0 +1,29 @@
+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
+ */
+export class MoreThanDateTime extends Operator {
+    constructor(operators) {
+        super(1);
+        this.moreThan = operators.getOperator(MoreThan);
+    }
+    createQuery(elasticKeywords, args) {
+        this.checkArgumentsCount(args);
+        const 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()]);
+    }
+    getOperatorNameTemplate() {
+        return ['search.operator.moreThan', Operator.INPUT_PLACEHOLDER];
+    }
+    serialize() {
+        return Operators.MORE_THAN_DATE_TIME;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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