@netgrif/components-core 6.0.1

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

@@ -0,0 +1,29 @@
+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
+ */
+export class MoreThanDate extends Operator {
+    constructor(operators) {
+        super(1);
+        this.moreThan = operators.getOperator(MoreThan);
+    }
+    createQuery(elasticKeywords, args) {
+        this.checkArgumentsCount(args);
+        const arg = moment(args[0]);
+        clearTimeInformation(arg);
+        arg.date(arg.date() + 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;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,27 @@
+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
+ */
+export class MoreThanEqualDateTime extends Operator {
+    constructor(operators) {
+        super(1);
+        this.moreThanEqual = operators.getOperator(MoreThanEqual);
+    }
+    createQuery(elasticKeywords, args) {
+        this.checkArgumentsCount(args);
+        const arg = moment(args[0]);
+        arg.milliseconds(0);
+        arg.seconds(0);
+        return this.moreThanEqual.createQuery(elasticKeywords, [arg.valueOf()]);
+    }
+    getOperatorNameTemplate() {
+        return ['search.operator.moreThanEqual', Operator.INPUT_PLACEHOLDER];
+    }
+    serialize() {
+        return Operators.MORE_THAN_EQUAL_DATE_TIME;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,27 @@
+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
+ */
+export class MoreThanEqualDate extends Operator {
+    constructor(operators) {
+        super(1);
+        this.moreThanEqual = operators.getOperator(MoreThanEqual);
+    }
+    createQuery(elasticKeywords, args) {
+        this.checkArgumentsCount(args);
+        const arg = moment(args[0]);
+        clearTimeInformation(arg);
+        return this.moreThanEqual.createQuery(elasticKeywords, [arg.valueOf()]);
+    }
+    getOperatorNameTemplate() {
+        return ['search.operator.moreThanEqual', Operator.INPUT_PLACEHOLDER];
+    }
+    serialize() {
+        return Operators.MORE_THAN_EQUAL_DATE;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

@@ -0,0 +1,17 @@
+import { Operator } from './operator';
+import { Operators } from './operators';
+/**
+ * A strict greater than operator for numeric fields.
+ */
+export class MoreThan extends Operator {
+    constructor() {
+        super(1, '>');
+    }
+    getOperatorNameTemplate() {
+        return ['search.operator.moreThan', Operator.INPUT_PLACEHOLDER];
+    }
+    serialize() {
+        return Operators.MORE_THAN;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9yZS10aGFuLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3NlYXJjaC9tb2RlbHMvb3BlcmF0b3IvbW9yZS10aGFuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxRQUFRLEVBQUMsTUFBTSxZQUFZLENBQUM7QUFDcEMsT0FBTyxFQUFDLFNBQVMsRUFBQyxNQUFNLGFBQWEsQ0FBQztBQUV0Qzs7R0FFRztBQUNILE1BQU0sT0FBTyxRQUFTLFNBQVEsUUFBZ0I7SUFDMUM7UUFDSSxLQUFLLENBQUMsQ0FBQyxFQUFFLEdBQUcsQ0FBQyxDQUFDO0lBQ2xCLENBQUM7SUFFRCx1QkFBdUI7UUFDbkIsT0FBTyxDQUFDLDBCQUEwQixFQUFFLFFBQVEsQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO0lBQ3BFLENBQUM7SUFFRCxTQUFTO1FBQ0wsT0FBTyxTQUFTLENBQUMsU0FBUyxDQUFDO0lBQy9CLENBQUM7Q0FDSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7T3BlcmF0b3J9IGZyb20gJy4vb3BlcmF0b3InO1xuaW1wb3J0IHtPcGVyYXRvcnN9IGZyb20gJy4vb3BlcmF0b3JzJztcblxuLyoqXG4gKiBBIHN0cmljdCBncmVhdGVyIHRoYW4gb3BlcmF0b3IgZm9yIG51bWVyaWMgZmllbGRzLlxuICovXG5leHBvcnQgY2xhc3MgTW9yZVRoYW4gZXh0ZW5kcyBPcGVyYXRvcjxudW1iZXI+IHtcbiAgICBjb25zdHJ1Y3RvcigpIHtcbiAgICAgICAgc3VwZXIoMSwgJz4nKTtcbiAgICB9XG5cbiAgICBnZXRPcGVyYXRvck5hbWVUZW1wbGF0ZSgpOiBBcnJheTxzdHJpbmc+IHtcbiAgICAgICAgcmV0dXJuIFsnc2VhcmNoLm9wZXJhdG9yLm1vcmVUaGFuJywgT3BlcmF0b3IuSU5QVVRfUExBQ0VIT0xERVJdO1xuICAgIH1cblxuICAgIHNlcmlhbGl6ZSgpOiBPcGVyYXRvcnMgfCBzdHJpbmcge1xuICAgICAgICByZXR1cm4gT3BlcmF0b3JzLk1PUkVfVEhBTjtcbiAgICB9XG59XG4iXX0=

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

@@ -0,0 +1,24 @@
+import { Operator } from './operator';
+import { Query } from '../query/query';
+import { Operators } from './operators';
+import { EqualsDateTime } from './equals-date-time';
+export class NotEqualsDateTime extends Operator {
+    constructor(operators) {
+        super(1);
+        this.equals = operators.getOperator(EqualsDateTime);
+    }
+    createQuery(elasticKeywords, args) {
+        const equalsQuery = this.equals.createQuery(elasticKeywords, args);
+        if (equalsQuery.isEmpty) {
+            return equalsQuery;
+        }
+        return new Query(`(!${equalsQuery.value})`);
+    }
+    getOperatorNameTemplate() {
+        return ['search.operator.notEquals', Operator.INPUT_PLACEHOLDER];
+    }
+    serialize() {
+        return Operators.NOT_EQUALS_DATE_TIME;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,27 @@
+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.
+ */
+export class NotEqualsDate extends Operator {
+    constructor(operators) {
+        super(1);
+        this.equals = operators.getOperator(EqualsDate);
+    }
+    createQuery(elasticKeywords, args) {
+        const equalsQuery = this.equals.createQuery(elasticKeywords, args);
+        if (equalsQuery.isEmpty) {
+            return equalsQuery;
+        }
+        return new Query(`(!${equalsQuery.value})`);
+    }
+    getOperatorNameTemplate() {
+        return ['search.operator.notEquals', Operator.INPUT_PLACEHOLDER];
+    }
+    serialize() {
+        return Operators.NOT_EQUALS_DATE;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,30 @@
+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.
+ */
+export class NotEquals extends Operator {
+    constructor(operators) {
+        super(1);
+        this.equals = operators.getOperator(Equals);
+    }
+    createQuery(elasticKeywords, args) {
+        const equalsQuery = this.equals.createQuery(elasticKeywords, args);
+        if (equalsQuery.isEmpty) {
+            return equalsQuery;
+        }
+        return new Query(`(!${equalsQuery.value})`);
+    }
+    getOperatorNameTemplate() {
+        return ['search.operator.notEquals', Operator.INPUT_PLACEHOLDER];
+    }
+    serialize() {
+        return Operators.NOT_EQUALS;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,124 @@
+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
+ */
+export class Operator {
+    constructor(numberOfOperands, 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
+     */
+    static escapeInput(input) {
+        if (typeof input === 'string') {
+            let escaped = false;
+            let output = '';
+            for (let 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])`
+     */
+    static query(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
+     */
+    static forEachKeyword(elasticKeywords, queryConstructor) {
+        const simpleQueries = [];
+        elasticKeywords.forEach(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
+     */
+    static wrapInputWithQuotes(input, forceWrap = false) {
+        if (typeof input === 'string' && (input.includes(' ') || forceWrap))
+            return { value: `"${input}"`, wasWrapped: true };
+        else
+            return { value: input, wasWrapped: false };
+    }
+    /**
+     * @returns the arity of the operator.
+     */
+    get numberOfOperands() {
+        return this._numberOfOperands;
+    }
+    /**
+     * 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.
+     */
+    createQuery(elasticKeywords, args, escapeArgs = true) {
+        this.checkArgumentsCount(args);
+        return Operator.forEachKeyword(elasticKeywords, (keyword) => {
+            const escapedValue = escapeArgs ?
+                Operator.escapeInput(args[0]) : ({ value: args[0], wasEscaped: false });
+            const wrappedValue = Operator.wrapInputWithQuotes(escapedValue.value, escapedValue.wasEscaped);
+            const 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
+     */
+    checkArgumentsCount(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(['<', '>']);
+//# 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"]}

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

@@ -0,0 +1,31 @@
+/**
+ * Represents the available {@link Operator} classes in a serializable form.
+ */
+export var Operators;
+(function (Operators) {
+    Operators["EQUALS"] = "equals";
+    Operators["EQUALS_DATE"] = "equals_date";
+    Operators["EQUALS_DATE_TIME"] = "equals_date_time";
+    Operators["IN_RANGE"] = "in_range";
+    Operators["IN_RANGE_DATE"] = "in_range_date";
+    Operators["IN_RANGE_DATE_TIME"] = "in_range_date_time";
+    Operators["IS_NULL"] = "is_null";
+    Operators["LESS_THAN"] = "less_than";
+    Operators["LESS_THAN_DATE"] = "less_than_date";
+    Operators["LESS_THAN_DATE_TIME"] = "less_than_date_time";
+    Operators["LESS_THAN_EQUAL"] = "less_than_equal";
+    Operators["LESS_THAN_EQUAL_DATE"] = "less_than_equal_date";
+    Operators["LESS_THAN_EQUAL_DATE_TIME"] = "less_than_equal_date_time";
+    Operators["LIKE"] = "like";
+    Operators["MORE_THAN"] = "more_than";
+    Operators["MORE_THAN_DATE"] = "more_than_date";
+    Operators["MORE_THAN_DATE_TIME"] = "more_than_date_time";
+    Operators["MORE_THAN_EQUAL"] = "more_than_equal";
+    Operators["MORE_THAN_EQUAL_DATE"] = "more_than_equal_date";
+    Operators["MORE_THAN_EQUAL_DATE_TIME"] = "more_than_equal_date_time";
+    Operators["NOT_EQUALS"] = "not_equals";
+    Operators["NOT_EQUALS_DATE"] = "not_equals_date";
+    Operators["NOT_EQUALS_DATE_TIME"] = "not_equals_date_time";
+    Operators["SUBSTRING"] = "substring";
+})(Operators || (Operators = {}));
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,27 @@
+import { Operator } from './operator';
+import { Query } from '../query/query';
+import { Operators } from './operators';
+/**
+ * Operator that matches if the input is a substring of some value.
+ * Can only be used on fields that are texts and are not indexed as keywords.
+ */
+export class Substring extends Operator {
+    constructor() {
+        super(1);
+    }
+    createQuery(elasticKeywords, args) {
+        this.checkArgumentsCount(args);
+        // TODO IMPROVEMENT 27.4.2020 - we could use regular expressions to search for substrings which would solve the unintuitive
+        //  behavior that occurs when we search for strings that contain spaces. We need to escape the input string in a special way
+        //  if we choose to do this
+        const escapedValue = Operator.escapeInput(args[0]).value;
+        return Operator.forEachKeyword(elasticKeywords, keyword => new Query(`(${keyword}:\\*${escapedValue}\\*)`));
+    }
+    getOperatorNameTemplate() {
+        return ['search.operator.substring', Operator.INPUT_PLACEHOLDER];
+    }
+    serialize() {
+        return Operators.SUBSTRING;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/search/models/operator-template-part-type.js

@@ -0,0 +1,15 @@
+/**
+ * Type of a processed operator template part/segment.
+ */
+export var OperatorTemplatePartType;
+(function (OperatorTemplatePartType) {
+    /**
+     * Template segment that represents an input field.
+     */
+    OperatorTemplatePartType["INPUT"] = "input";
+    /**
+     * Template segment that represents a text display
+     */
+    OperatorTemplatePartType["TEXT"] = "text";
+})(OperatorTemplatePartType || (OperatorTemplatePartType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3BlcmF0b3ItdGVtcGxhdGUtcGFydC10eXBlLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3NlYXJjaC9tb2RlbHMvb3BlcmF0b3ItdGVtcGxhdGUtcGFydC10eXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFOLElBQVksd0JBU1g7QUFURCxXQUFZLHdCQUF3QjtJQUNoQzs7T0FFRztJQUNILDJDQUFlLENBQUE7SUFDZjs7T0FFRztJQUNILHlDQUFhLENBQUE7QUFDakIsQ0FBQyxFQVRXLHdCQUF3QixLQUF4Qix3QkFBd0IsUUFTbkMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFR5cGUgb2YgYSBwcm9jZXNzZWQgb3BlcmF0b3IgdGVtcGxhdGUgcGFydC9zZWdtZW50LlxuICovXG5leHBvcnQgZW51bSBPcGVyYXRvclRlbXBsYXRlUGFydFR5cGUge1xuICAgIC8qKlxuICAgICAqIFRlbXBsYXRlIHNlZ21lbnQgdGhhdCByZXByZXNlbnRzIGFuIGlucHV0IGZpZWxkLlxuICAgICAqL1xuICAgIElOUFVUID0gJ2lucHV0JyxcbiAgICAvKipcbiAgICAgKiBUZW1wbGF0ZSBzZWdtZW50IHRoYXQgcmVwcmVzZW50cyBhIHRleHQgZGlzcGxheVxuICAgICAqL1xuICAgIFRFWFQgPSAndGV4dCcsXG59XG4iXX0=

package/esm2015/lib/search/models/operator-template-part.js

@@ -0,0 +1,31 @@
+import { OperatorTemplatePartType } from './operator-template-part-type';
+/**
+ * Represents a process operator template part/segment.
+ *
+ * Is used to be iterated over by ngFor to display a combination of text segments and user inputs that together create an operator input GUI
+ */
+export class OperatorTemplatePart {
+    /**
+     * The
+     * @param part either the displayed text or a `FormControl` object, that represents the operator template segment.
+     * @param id for ngFor trackBy comparison
+     * @param first whether it is the first input in the template
+     */
+    constructor(part, id, first = false) {
+        this.id = id;
+        this.first = first;
+        this._content = part;
+        this._type = typeof part === 'string' ? OperatorTemplatePartType.TEXT : OperatorTemplatePartType.INPUT;
+    }
+    /**
+     * @returns [TEXT]{@link OperatorTemplatePartType#TEXT} if the segment is a text (content has type `string`),
+     * or [INPUT]{@link OperatorTemplatePartType#INPUT} if the segment is an input field (content has type `FormControl`)
+     */
+    get type() {
+        return this._type;
+    }
+    get content() {
+        return this._content;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/search/models/persistance/filter-metadata-allowed-nets.js

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

package/esm2015/lib/search/models/persistance/filter-metadata.js

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

package/esm2015/lib/search/models/persistance/filter-text-segment.js

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

package/esm2015/lib/search/models/persistance/generator-metadata.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/search/models/persistance/saved-filter-metadata.js

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