@netgrif/components-core 6.0.1

package/esm5/lib/search/search-operand-input-component/abstract-search-operand-input.component.js

@@ -0,0 +1,113 @@
+import { Input, ViewChild } from '@angular/core';
+import { SearchInputType } from '../models/category/search-input-type';
+import { debounceTime } from 'rxjs/operators';
+var AbstractSearchOperandInputComponent = /** @class */ (function () {
+    function AbstractSearchOperandInputComponent() {
+        var _this = this;
+        /**
+         * Whether the contents displayed in this component can be edited by the user or not.
+         *
+         * Defaults to `true`
+         */
+        this.editable = true;
+        this._inputConfirmed = false;
+        this._initialExpansion = true;
+        this.renderSelection = function (selection) { return _this._renderSelection(selection); };
+    }
+    AbstractSearchOperandInputComponent.prototype.ngOnInit = function () {
+        var _this = this;
+        if (this.inputType === SearchInputType.AUTOCOMPLETE) {
+            this._autocompleteChange = this.inputFormControl.valueChanges.subscribe(function (val) {
+                setTimeout(function () {
+                    _this._inputConfirmed = !!val && (typeof val !== 'string');
+                });
+            });
+        }
+        if (this.isInputValueSet()) {
+            this._inputConfirmed = true;
+        }
+    };
+    AbstractSearchOperandInputComponent.prototype.ngOnDestroy = function () {
+        if (this._autocompleteChange && !this._autocompleteChange.closed) {
+            this._autocompleteChange.unsubscribe();
+        }
+    };
+    Object.defineProperty(AbstractSearchOperandInputComponent.prototype, "filteredOptions$", {
+        get: function () {
+            if (!this._filteredOptions$) {
+                this._filteredOptions$ = this.filterOptionsFunction(this.inputFormControl.valueChanges.pipe(debounceTime(600)));
+            }
+            return this._filteredOptions$;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AbstractSearchOperandInputComponent.prototype, "isInputFilled", {
+        get: function () {
+            if (!this._inputConfirmed) {
+                return false;
+            }
+            return this.isInputValueSet();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AbstractSearchOperandInputComponent.prototype, "categoryInput", {
+        set: function (input) {
+            if (input) {
+                if (!this.first && this._initialExpansion) {
+                    this._initialExpansion = false;
+                    return;
+                }
+                this._initialExpansion = false;
+                if (!this.isInputFilled) {
+                    setTimeout(function () {
+                        input.nativeElement.focus();
+                    });
+                }
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AbstractSearchOperandInputComponent.prototype.confirmInput = function () {
+        this._inputConfirmed = true;
+    };
+    AbstractSearchOperandInputComponent.prototype.editInput = function () {
+        if (!this.editable) {
+            return;
+        }
+        this._inputConfirmed = false;
+    };
+    /**
+     * Autocomplete `displayWith` function
+     * @param selection the selected option
+     */
+    AbstractSearchOperandInputComponent.prototype._renderSelection = function (selection) {
+        return selection ? selection.text : '';
+    };
+    AbstractSearchOperandInputComponent.prototype.isInputValueSet = function () {
+        if (this.inputType === SearchInputType.AUTOCOMPLETE) {
+            return !!this.inputFormControl.value
+                && (typeof this.inputFormControl.value !== 'string');
+        }
+        if (this.inputType === SearchInputType.TEXT) {
+            return this.inputFormControl.value !== undefined
+                && this.inputFormControl.value !== null
+                && this.inputFormControl.value.length > 0;
+        }
+        return this.inputFormControl.value !== undefined
+            && this.inputFormControl.value !== null;
+    };
+    AbstractSearchOperandInputComponent.propDecorators = {
+        editable: [{ type: Input }],
+        inputFormControl: [{ type: Input }],
+        inputType: [{ type: Input }],
+        first: [{ type: Input }],
+        filterOptionsFunction: [{ type: Input }],
+        categoryInput: [{ type: ViewChild, args: ['operandInput',] }]
+    };
+    return AbstractSearchOperandInputComponent;
+}());
+export { AbstractSearchOperandInputComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-search-operand-input.component.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/search/search-operand-input-component/abstract-search-operand-input.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {ElementRef, Input, OnDestroy, OnInit, ViewChild} from '@angular/core';\nimport {FormControl} from '@angular/forms';\nimport {SearchInputType} from '../models/category/search-input-type';\nimport {Observable, Subscription} from 'rxjs';\nimport {SearchAutocompleteOption} from '../models/category/search-autocomplete-option';\nimport {debounceTime} from 'rxjs/operators';\n\n\nexport abstract class AbstractSearchOperandInputComponent implements OnInit, OnDestroy {\n\n    /**\n     * Whether the contents displayed in this component can be edited by the user or not.\n     *\n     * Defaults to `true`\n     */\n    @Input() editable = true;\n    @Input() inputFormControl: FormControl;\n    @Input() inputType: SearchInputType;\n    @Input() first: boolean;\n    /**\n     * Only if the input is of type [AUTOCOMPLETE{@link SearchInputType#AUTOCOMPLETE}\n     */\n    @Input() filterOptionsFunction: (userInput: Observable<string>) => Observable<Array<SearchAutocompleteOption<unknown>>>;\n\n    protected _inputConfirmed = false;\n\n    private _filteredOptions$: Observable<Array<SearchAutocompleteOption<unknown>>>;\n\n    private _autocompleteChange: Subscription;\n\n    private _initialExpansion = true;\n\n    public renderSelection = (selection: SearchAutocompleteOption<unknown>) => this._renderSelection(selection);\n\n    ngOnInit(): void {\n        if (this.inputType === SearchInputType.AUTOCOMPLETE) {\n            this._autocompleteChange = this.inputFormControl.valueChanges.subscribe(val => {\n                setTimeout(() => {\n                    this._inputConfirmed = !!val && (typeof val !== 'string');\n                });\n            });\n        }\n\n        if (this.isInputValueSet()) {\n            this._inputConfirmed = true;\n        }\n    }\n\n    ngOnDestroy(): void {\n        if (this._autocompleteChange && !this._autocompleteChange.closed) {\n            this._autocompleteChange.unsubscribe();\n        }\n    }\n\n    public get filteredOptions$(): Observable<Array<SearchAutocompleteOption<unknown>>> {\n        if (!this._filteredOptions$) {\n            this._filteredOptions$ = this.filterOptionsFunction(this.inputFormControl.valueChanges.pipe(debounceTime(600)));\n        }\n        return this._filteredOptions$;\n    }\n\n    public get isInputFilled(): boolean {\n        if (!this._inputConfirmed) {\n            return false;\n        }\n\n        return this.isInputValueSet();\n    }\n\n    @ViewChild('operandInput')\n    public set categoryInput(input: ElementRef<HTMLInputElement>) {\n        if (input) {\n            if (!this.first && this._initialExpansion) {\n                this._initialExpansion = false;\n                return;\n            }\n            this._initialExpansion = false;\n\n            if (!this.isInputFilled) {\n                setTimeout(() => {\n                    input.nativeElement.focus();\n                });\n            }\n        }\n    }\n\n    public confirmInput(): void {\n        this._inputConfirmed = true;\n    }\n\n    public editInput(): void {\n        if (!this.editable) {\n            return;\n        }\n\n        this._inputConfirmed = false;\n    }\n\n    /**\n     * Autocomplete `displayWith` function\n     * @param selection the selected option\n     */\n    protected _renderSelection(selection: SearchAutocompleteOption<unknown>): string {\n        return selection ? selection.text : '';\n    }\n\n    protected isInputValueSet(): boolean {\n        if (this.inputType === SearchInputType.AUTOCOMPLETE) {\n            return !!this.inputFormControl.value\n                && (typeof this.inputFormControl.value !== 'string');\n        }\n        if (this.inputType === SearchInputType.TEXT) {\n            return this.inputFormControl.value !== undefined\n                && this.inputFormControl.value !== null\n                && this.inputFormControl.value.length > 0;\n        }\n        return this.inputFormControl.value !== undefined\n            && this.inputFormControl.value !== null;\n    }\n}\n"]}

package/esm5/lib/search/search-predicate-component/abstract-search-predicate.component.js

@@ -0,0 +1,162 @@
+import { Inject, Input, ViewChild } from '@angular/core';
+import { NAE_SEARCH_CATEGORIES } from '../category-factory/search-categories-injection-token';
+import { Query } from '../models/query/query';
+import { LoggerService } from '../../logger/services/logger.service';
+import { AdvancedSearchComponentInitializationService } from '../advanced-search-component-initialization-service/advanced-search-component-initialization.service';
+import { CategoryFactory } from '../category-factory/category-factory';
+/**
+ * Is responsible for the interactive creation of a single {@link ElementaryPredicate} object instance.
+ */
+var AbstractSearchPredicateComponent = /** @class */ (function () {
+    function AbstractSearchPredicateComponent(_naeSearchCategories, _logger, _initializationService, _categoryFactory) {
+        var _this = this;
+        this._naeSearchCategories = _naeSearchCategories;
+        this._logger = _logger;
+        this._initializationService = _initializationService;
+        this._categoryFactory = _categoryFactory;
+        /**
+         * Whether the contents displayed in this component can be edited by the user or not.
+         *
+         * Defaults to `true`
+         */
+        this.editable = true;
+        /**
+         * Lambda that is used to preserve `this` reference in HTML binding.
+         *
+         * See [_renderSelection()]{@link AbstractSearchPredicateComponent#_renderSelection} for information about the transform function.
+         * @param option the {@link SearchAutocompleteOption} object that was selected in the autocomplete list.
+         */
+        this.renderSelection = function (option) { return _this._renderSelection(option); };
+    }
+    AbstractSearchPredicateComponent.prototype.ngOnInit = function () {
+        var _this = this;
+        var found = false;
+        this._searchCategories = this._naeSearchCategories.map(function (category) {
+            // if the provided generator is the same class as one of the injected search categories
+            if (_this.generator && _this.generator.constructor === category) {
+                found = true;
+                _this.categoryChanged(_this.generator);
+                return _this.generator;
+            }
+            return _this._categoryFactory.get(category);
+        });
+        if (this.generator && !found) {
+            this._logger.error('Provided predicate generator is not an allowed category from the NAE_SEARCH_CATEGORIES injection token!'
+                + ' Behavior in this case is undefined.');
+        }
+        this.predicate.setMetadataGenerator(function () {
+            if (!!_this._selectedCategory) {
+                return _this._selectedCategory.createMetadata();
+            }
+            return undefined;
+        });
+        this.predicate.setFilterTextSegmentsGenerator(function () {
+            if (!!_this._selectedCategory) {
+                return _this._selectedCategory.createFilterTextSegments();
+            }
+            return [];
+        });
+    };
+    AbstractSearchPredicateComponent.prototype.ngOnDestroy = function () {
+        var _this = this;
+        if (this._predicateChange && !this._predicateChange.closed) {
+            this._predicateChange.unsubscribe();
+        }
+        this._searchCategories.forEach(function (cat) {
+            if (cat !== _this.generator) {
+                cat.destroy();
+            }
+        });
+    };
+    Object.defineProperty(AbstractSearchPredicateComponent.prototype, "searchCategories", {
+        get: function () {
+            return this._searchCategories;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AbstractSearchPredicateComponent.prototype, "categoryInput", {
+        set: function (input) {
+            if (input && this._initializationService.isInitialized) {
+                setTimeout(function () {
+                    input.focus();
+                    input.open();
+                });
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AbstractSearchPredicateComponent.prototype, "selectedCategory", {
+        get: function () {
+            return this._selectedCategory;
+        },
+        set: function (newCategory) {
+            this.categoryChanged(newCategory);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AbstractSearchPredicateComponent.prototype.remove = function () {
+        this.remove$.next(this.predicateId);
+    };
+    AbstractSearchPredicateComponent.prototype.categoryChanged = function (newCategory) {
+        var _this = this;
+        if (this.selectedCategory !== undefined) {
+            this.selectedCategory.reset();
+        }
+        this._selectedCategory = newCategory;
+        if (newCategory !== undefined) {
+            if (this._predicateChange) {
+                this._predicateChange.unsubscribe();
+            }
+            this._predicateChange = newCategory.generatedPredicate$.subscribe(function (predicate) { return _this.processPredicateChange(predicate); });
+        }
+    };
+    AbstractSearchPredicateComponent.prototype.clearCategorySelection = function () {
+        if (!this.editable) {
+            return;
+        }
+        this.categoryChanged(undefined);
+    };
+    /**
+     * Transforms a {@link SearchAutocompleteOption} object into it's name.
+     * Used for displaying user selection in the input field, when an autocomplete option is selected.
+     * @param option the object we want to transform. It might not exist if user input doesn't match any autocomplete option
+     * @returns option name if it exists, empty string otherwise
+     */
+    AbstractSearchPredicateComponent.prototype._renderSelection = function (option) {
+        return option ? option.text : '';
+    };
+    /**
+     * Notifies the `EditableElementaryPredicate` about changes to the predicate generated by the selected `Category`.
+     * @param newPredicate predicate generated by the selected `Category`
+     */
+    AbstractSearchPredicateComponent.prototype.processPredicateChange = function (newPredicate) {
+        if (newPredicate === undefined) {
+            this.predicate.query = Query.emptyQuery();
+            this._logger.debug('Editable query changed to empty query');
+        }
+        else {
+            this.predicate.query = newPredicate.query;
+            this._logger.debug("Editable query changed to: " + newPredicate.query.value);
+        }
+    };
+    AbstractSearchPredicateComponent.ctorParameters = function () { return [
+        { type: Array, decorators: [{ type: Inject, args: [NAE_SEARCH_CATEGORIES,] }] },
+        { type: LoggerService },
+        { type: AdvancedSearchComponentInitializationService },
+        { type: CategoryFactory }
+    ]; };
+    AbstractSearchPredicateComponent.propDecorators = {
+        editable: [{ type: Input }],
+        predicate: [{ type: Input }],
+        predicateId: [{ type: Input }],
+        remove$: [{ type: Input }],
+        generator: [{ type: Input }],
+        categoryInput: [{ type: ViewChild, args: ['categoryInput',] }]
+    };
+    return AbstractSearchPredicateComponent;
+}());
+export { AbstractSearchPredicateComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-search-predicate.component.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/search/search-predicate-component/abstract-search-predicate.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Input, OnDestroy, OnInit, Type, ViewChild} from '@angular/core';\nimport {Subject, Subscription} from 'rxjs';\nimport {NAE_SEARCH_CATEGORIES} from '../category-factory/search-categories-injection-token';\nimport {Category} from '../models/category/category';\nimport {SearchAutocompleteOption} from '../models/category/search-autocomplete-option';\nimport {ElementaryPredicate} from '../models/predicate/elementary-predicate';\nimport {Query} from '../models/query/query';\nimport {LoggerService} from '../../logger/services/logger.service';\nimport {MatSelect} from '@angular/material/select';\nimport {EditableElementaryPredicate} from '../models/predicate/editable-elementary-predicate';\nimport {\n    AdvancedSearchComponentInitializationService\n} from '../advanced-search-component-initialization-service/advanced-search-component-initialization.service';\nimport {CategoryFactory} from '../category-factory/category-factory';\n\n\n/**\n * Is responsible for the interactive creation of a single {@link ElementaryPredicate} object instance.\n */\nexport abstract class AbstractSearchPredicateComponent implements OnInit, OnDestroy {\n\n    /**\n     * Whether the contents displayed in this component can be edited by the user or not.\n     *\n     * Defaults to `true`\n     */\n    @Input() editable = true;\n    @Input() predicate: EditableElementaryPredicate;\n    @Input() predicateId: number;\n    @Input() remove$: Subject<number>;\n    /**\n     * Optional generator with prefilled values. Can be used to add prefilled predicate components to the search GUI.\n     */\n    @Input() generator: Category<any> | undefined;\n\n    protected _selectedCategory: Category<any>;\n\n    protected _predicateChange: Subscription;\n\n    protected _searchCategories: Array<Category<any>>;\n\n    protected constructor(@Inject(NAE_SEARCH_CATEGORIES) private _naeSearchCategories: Array<Type<Category<any>>>,\n                          protected _logger: LoggerService,\n                          protected _initializationService: AdvancedSearchComponentInitializationService,\n                          protected _categoryFactory: CategoryFactory) {\n    }\n\n    ngOnInit() {\n        let found = false;\n        this._searchCategories = this._naeSearchCategories.map(category => {\n            // if the provided generator is the same class as one of the injected search categories\n            if (this.generator && this.generator.constructor === category) {\n                found = true;\n                this.categoryChanged(this.generator);\n                return this.generator;\n            }\n            return this._categoryFactory.get(category);\n        });\n\n        if (this.generator && !found) {\n            this._logger.error('Provided predicate generator is not an allowed category from the NAE_SEARCH_CATEGORIES injection token!'\n                + ' Behavior in this case is undefined.');\n        }\n\n        this.predicate.setMetadataGenerator(() => {\n            if (!!this._selectedCategory) {\n                return this._selectedCategory.createMetadata();\n            }\n            return undefined;\n        });\n\n        this.predicate.setFilterTextSegmentsGenerator(() => {\n            if (!!this._selectedCategory) {\n                return this._selectedCategory.createFilterTextSegments();\n            }\n            return [];\n        });\n    }\n\n    ngOnDestroy(): void {\n        if (this._predicateChange && !this._predicateChange.closed) {\n            this._predicateChange.unsubscribe();\n        }\n        this._searchCategories.forEach(cat => {\n            if (cat !== this.generator) {\n                cat.destroy();\n            }\n        });\n    }\n\n    public get searchCategories(): Array<Category<any>> {\n        return this._searchCategories;\n    }\n\n    @ViewChild('categoryInput')\n    public set categoryInput(input: MatSelect) {\n        if (input && this._initializationService.isInitialized) {\n            setTimeout(() => {\n                input.focus();\n                input.open();\n            });\n        }\n    }\n\n    public get selectedCategory(): Category<any> {\n        return this._selectedCategory;\n    }\n\n    public set selectedCategory(newCategory: Category<any>) {\n        this.categoryChanged(newCategory);\n    }\n\n    /**\n     * Lambda that is used to preserve `this` reference in HTML binding.\n     *\n     * See [_renderSelection()]{@link AbstractSearchPredicateComponent#_renderSelection} for information about the transform function.\n     * @param option the {@link SearchAutocompleteOption} object that was selected in the autocomplete list.\n     */\n    public renderSelection = (option: SearchAutocompleteOption<unknown>) => this._renderSelection(option);\n\n    public remove(): void {\n        this.remove$.next(this.predicateId);\n    }\n\n    public categoryChanged(newCategory: Category<any>): void {\n        if (this.selectedCategory !== undefined) {\n            this.selectedCategory.reset();\n        }\n        this._selectedCategory = newCategory;\n        if (newCategory !== undefined) {\n            if (this._predicateChange) {\n                this._predicateChange.unsubscribe();\n            }\n            this._predicateChange = newCategory.generatedPredicate$.subscribe(predicate => this.processPredicateChange(predicate));\n        }\n    }\n\n    public clearCategorySelection(): void {\n        if (!this.editable) {\n            return;\n        }\n\n        this.categoryChanged(undefined);\n    }\n\n    /**\n     * Transforms a {@link SearchAutocompleteOption} object into it's name.\n     * Used for displaying user selection in the input field, when an autocomplete option is selected.\n     * @param option the object we want to transform. It might not exist if user input doesn't match any autocomplete option\n     * @returns option name if it exists, empty string otherwise\n     */\n    protected _renderSelection(option: SearchAutocompleteOption<unknown>): string {\n        return option ? option.text : '';\n    }\n\n    /**\n     * Notifies the `EditableElementaryPredicate` about changes to the predicate generated by the selected `Category`.\n     * @param newPredicate predicate generated by the selected `Category`\n     */\n    protected processPredicateChange(newPredicate: ElementaryPredicate | undefined): void {\n        if (newPredicate === undefined) {\n            this.predicate.query = Query.emptyQuery();\n            this._logger.debug('Editable query changed to empty query');\n        } else {\n            this.predicate.query = newPredicate.query;\n            this._logger.debug(`Editable query changed to: ${newPredicate.query.value}`);\n        }\n    }\n}\n"]}