@netgrif/components-core 6.0.1

package/esm2015/lib/search/search-component/abstract-search.component.js

@@ -0,0 +1,171 @@
+import { SearchService } from '../search-service/search.service';
+import { LoggerService } from '../../logger/services/logger.service';
+import { DialogService } from '../../dialog/services/dialog.service';
+import { TranslateService } from '@ngx-translate/core';
+import { NAE_SEARCH_COMPONENT_CONFIGURATION } from '../models/component-configuration/search-component-configuration-injection-token';
+import { EventEmitter, Inject, Input, Optional, Output } from '@angular/core';
+import { SearchMode } from '../models/component-configuration/search-mode';
+import { UserFiltersService } from '../../filter/user-filters.service';
+import { AllowedNetsService } from '../../allowed-nets/services/allowed-nets.service';
+import { NAE_SEARCH_CATEGORIES } from '../category-factory/search-categories-injection-token';
+import { ViewIdService } from '../../user/services/view-id.service';
+import { NAE_FILTERS_FILTER } from '../../filter/models/filters-filter-injection-token';
+import { Filter } from '../../filter/models/filter';
+import { NAE_NAVIGATION_ITEM_TASK_DATA } from '../../navigation/model/filter-case-injection-token';
+/**
+ * A universal search component that can be used to interactively create search predicates for anything with supported categories.
+ *
+ * This component is responsible for the interactive creation of an AND {@link ClausePredicate} object instance.
+ * The nested Predicates are OR {@link ClausePredicate} instances created by {@link AbstractSearchClauseComponent}.
+ *
+ * Search categories must be provided by the {@link NAE_SEARCH_CATEGORIES} injection token.
+ * Default factory methods for [task]{@link defaultTaskSearchCategoriesFactory} and
+ * [case]{@link defaultCaseSearchCategoriesFactory} search categories exist. See their documentation for more information.
+ *
+ * The search component's visuals can be configured either by the {@link NAE_SEARCH_COMPONENT_CONFIGURATION} injection token,
+ * or by the appropriate component inputs. The injection token configuration takes precedence over the inputs if both are present.
+ */
+export class AbstractSearchComponent {
+    constructor(_searchService, _logger, _dialogService, _translate, _userFilterService, _allowedNetsService, _viewIdService, _searchCategories, _configuration, _filtersFilter = null, _navigationItemTaskData = null) {
+        this._searchService = _searchService;
+        this._logger = _logger;
+        this._dialogService = _dialogService;
+        this._translate = _translate;
+        this._userFilterService = _userFilterService;
+        this._allowedNetsService = _allowedNetsService;
+        this._viewIdService = _viewIdService;
+        this._searchCategories = _searchCategories;
+        this._configuration = _configuration;
+        this._filtersFilter = _filtersFilter;
+        this._navigationItemTaskData = _navigationItemTaskData;
+        this._showSearchIcon = true;
+        this._showSearchToggleButton = true;
+        this._showAdvancedSearchHelp = true;
+        this._showSaveFilterButton = true;
+        this._showLoadFilterButton = true;
+        this._initialSearchMode = SearchMode.FULLTEXT;
+        /**
+         * Set data request body, that is sent to the filter in addition to the default body.
+         * The default body is applied first and can be overridden by this argument.
+         */
+        this.additionalFilterData = {};
+        /**
+         * The emitted data contains the filter case object
+         */
+        this.filterLoaded = new EventEmitter();
+        /**
+         * The emitted data contains only the saved case's ID
+         */
+        this.filterSaved = new EventEmitter();
+        if (this._configuration === null) {
+            this._configuration = {};
+        }
+    }
+    ngOnInit() {
+        this.advancedSearchDisplayed = this.initialSearchMode === SearchMode.ADVANCED;
+    }
+    get showSearchIcon() {
+        var _a;
+        return (_a = this._configuration.showSearchIcon) !== null && _a !== void 0 ? _a : this._showSearchIcon;
+    }
+    set showSearchIcon(value) {
+        this._showSearchIcon = value;
+    }
+    get showAdvancedSearchHelp() {
+        var _a;
+        return (_a = this._configuration.showAdvancedSearchHelp) !== null && _a !== void 0 ? _a : this._showAdvancedSearchHelp;
+    }
+    set showAdvancedSearchHelp(value) {
+        this._showAdvancedSearchHelp = value;
+    }
+    get showSaveFilterButton() {
+        var _a;
+        return (_a = this._configuration.showSaveFilterButton) !== null && _a !== void 0 ? _a : this._showSaveFilterButton;
+    }
+    set showSaveFilterButton(value) {
+        this._showSaveFilterButton = value;
+    }
+    get showLoadFilterButton() {
+        var _a;
+        return (_a = this._configuration.showLoadFilterButton) !== null && _a !== void 0 ? _a : this._showLoadFilterButton;
+    }
+    set showLoadFilterButton(value) {
+        this._showLoadFilterButton = value;
+    }
+    get initialSearchMode() {
+        var _a;
+        return (_a = this._configuration.initialSearchMode) !== null && _a !== void 0 ? _a : this._initialSearchMode;
+    }
+    set initialSearchMode(value) {
+        this._initialSearchMode = value;
+    }
+    get showSearchToggleButton() {
+        var _a;
+        return (_a = this._configuration.showSearchToggleButton) !== null && _a !== void 0 ? _a : this._showSearchToggleButton;
+    }
+    set showSearchToggleButton(value) {
+        this._showSearchToggleButton = value;
+    }
+    hasPredicates() {
+        return Array.from(this._searchService.rootPredicate.getPredicateMap().values()).some(value => value.isVisible);
+    }
+    toggleSearchMode() {
+        if (this.advancedSearchDisplayed) {
+            this._searchService.clearPredicates();
+        }
+        else {
+            this._searchService.clearFullTextFilter();
+        }
+        this.advancedSearchDisplayed = !this.advancedSearchDisplayed;
+    }
+    showHelp() {
+        this._dialogService.openAlertDialog(this._translate.instant('search.help.title'), this._translate.instant('search.help.text'));
+    }
+    /**
+     * The saved filter data are emitted into the [filterSaved]{@link AbstractSearchComponent#filterSaved} `EventEmitter`
+     */
+    saveFilter() {
+        var _a, _b;
+        this._userFilterService.save(this._searchService, this._allowedNetsService.allowedNetsIdentifiers, this._searchCategories, this._viewIdService.viewId, this.additionalFilterData, (_a = this._configuration.saveFilterWithDefaultCategories) !== null && _a !== void 0 ? _a : true, (_b = this._configuration.inheritAllowedNets) !== null && _b !== void 0 ? _b : true, this._navigationItemTaskData).subscribe(savedFilterData => {
+            if (savedFilterData) {
+                this.filterSaved.emit(savedFilterData);
+            }
+        });
+    }
+    /**
+     * The loaded filter data are emitted into the [filterLoaded]{@link AbstractSearchComponent#filterLoaded} `EventEmitter`
+     */
+    loadFilter() {
+        var _a;
+        this._userFilterService.load(this._searchService.filterType, (_a = this._filtersFilter) !== null && _a !== void 0 ? _a : undefined).subscribe(savedFilterData => {
+            if (savedFilterData) {
+                this.filterLoaded.emit(savedFilterData);
+            }
+        });
+    }
+}
+AbstractSearchComponent.ctorParameters = () => [
+    { type: SearchService },
+    { type: LoggerService },
+    { type: DialogService },
+    { type: TranslateService },
+    { type: UserFiltersService },
+    { type: AllowedNetsService },
+    { type: ViewIdService },
+    { type: Array, decorators: [{ type: Inject, args: [NAE_SEARCH_CATEGORIES,] }] },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [NAE_SEARCH_COMPONENT_CONFIGURATION,] }] },
+    { type: Filter, decorators: [{ type: Optional }, { type: Inject, args: [NAE_FILTERS_FILTER,] }] },
+    { type: Array, decorators: [{ type: Optional }, { type: Inject, args: [NAE_NAVIGATION_ITEM_TASK_DATA,] }] }
+];
+AbstractSearchComponent.propDecorators = {
+    additionalFilterData: [{ type: Input }],
+    filterLoaded: [{ type: Output }],
+    filterSaved: [{ type: Output }],
+    showSearchIcon: [{ type: Input }],
+    showAdvancedSearchHelp: [{ type: Input }],
+    showSaveFilterButton: [{ type: Input }],
+    showLoadFilterButton: [{ type: Input }],
+    initialSearchMode: [{ type: Input }],
+    showSearchToggleButton: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-search.component.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/search/search-component/abstract-search.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {SearchService} from '../search-service/search.service';\nimport {LoggerService} from '../../logger/services/logger.service';\nimport {DialogService} from '../../dialog/services/dialog.service';\nimport {TranslateService} from '@ngx-translate/core';\nimport {NAE_SEARCH_COMPONENT_CONFIGURATION} from '../models/component-configuration/search-component-configuration-injection-token';\nimport {EventEmitter, Inject, Input, OnInit, Optional, Output, Type} from '@angular/core';\nimport {SearchComponentConfiguration} from '../models/component-configuration/search-component-configuration';\nimport {SearchMode} from '../models/component-configuration/search-mode';\nimport {UserFiltersService} from '../../filter/user-filters.service';\nimport {AllowedNetsService} from '../../allowed-nets/services/allowed-nets.service';\nimport {NAE_SEARCH_CATEGORIES} from '../category-factory/search-categories-injection-token';\nimport {Category} from '../models/category/category';\nimport {SavedFilterMetadata} from '../models/persistance/saved-filter-metadata';\nimport {ViewIdService} from '../../user/services/view-id.service';\nimport {NAE_FILTERS_FILTER} from '../../filter/models/filters-filter-injection-token';\nimport {Filter} from '../../filter/models/filter';\nimport {TaskSetDataRequestFields} from '../../resources/interface/task-set-data-request-body';\nimport {NAE_NAVIGATION_ITEM_TASK_DATA} from '../../navigation/model/filter-case-injection-token';\nimport {DataGroup} from '../../resources/interface/data-groups';\n\n/**\n * A universal search component that can be used to interactively create search predicates for anything with supported categories.\n *\n * This component is responsible for the interactive creation of an AND {@link ClausePredicate} object instance.\n * The nested Predicates are OR {@link ClausePredicate} instances created by {@link AbstractSearchClauseComponent}.\n *\n * Search categories must be provided by the {@link NAE_SEARCH_CATEGORIES} injection token.\n * Default factory methods for [task]{@link defaultTaskSearchCategoriesFactory} and\n * [case]{@link defaultCaseSearchCategoriesFactory} search categories exist. See their documentation for more information.\n *\n * The search component's visuals can be configured either by the {@link NAE_SEARCH_COMPONENT_CONFIGURATION} injection token,\n * or by the appropriate component inputs. The injection token configuration takes precedence over the inputs if both are present.\n */\nexport abstract class AbstractSearchComponent implements SearchComponentConfiguration, OnInit {\n\n    public advancedSearchDisplayed;\n\n    private _showSearchIcon = true;\n    private _showSearchToggleButton = true;\n    private _showAdvancedSearchHelp = true;\n    private _showSaveFilterButton = true;\n    private _showLoadFilterButton = true;\n    private _initialSearchMode = SearchMode.FULLTEXT;\n\n    /**\n     * Set data request body, that is sent to the filter in addition to the default body.\n     * The default body is applied first and can be overridden by this argument.\n     */\n    @Input() additionalFilterData: TaskSetDataRequestFields = {};\n\n    /**\n     * The emitted data contains the filter case object\n     */\n    @Output() filterLoaded: EventEmitter<SavedFilterMetadata> = new EventEmitter();\n    /**\n     * The emitted data contains only the saved case's ID\n     */\n    @Output() filterSaved: EventEmitter<SavedFilterMetadata> = new EventEmitter();\n\n    protected constructor(protected _searchService: SearchService,\n                          protected _logger: LoggerService,\n                          protected _dialogService: DialogService,\n                          protected _translate: TranslateService,\n                          protected _userFilterService: UserFiltersService,\n                          protected _allowedNetsService: AllowedNetsService,\n                          protected _viewIdService: ViewIdService,\n                          @Inject(NAE_SEARCH_CATEGORIES) protected _searchCategories: Array<Type<Category<any>>>,\n                          @Optional() @Inject(NAE_SEARCH_COMPONENT_CONFIGURATION) protected _configuration: SearchComponentConfiguration,\n                          @Optional() @Inject(NAE_FILTERS_FILTER) protected _filtersFilter: Filter = null,\n                          @Optional() @Inject(NAE_NAVIGATION_ITEM_TASK_DATA) protected _navigationItemTaskData: Array<DataGroup> = null) {\n        if (this._configuration === null) {\n            this._configuration = {};\n        }\n    }\n\n    ngOnInit(): void {\n        this.advancedSearchDisplayed = this.initialSearchMode === SearchMode.ADVANCED;\n    }\n\n    get showSearchIcon(): boolean {\n        return this._configuration.showSearchIcon ?? this._showSearchIcon;\n    }\n\n    @Input() set showSearchIcon(value: boolean) {\n        this._showSearchIcon = value;\n    }\n\n    get showAdvancedSearchHelp(): boolean {\n        return this._configuration.showAdvancedSearchHelp ?? this._showAdvancedSearchHelp;\n    }\n\n    @Input() set showAdvancedSearchHelp(value: boolean) {\n        this._showAdvancedSearchHelp = value;\n    }\n\n    get showSaveFilterButton(): boolean {\n        return this._configuration.showSaveFilterButton ?? this._showSaveFilterButton;\n    }\n\n    @Input() set showSaveFilterButton(value: boolean) {\n        this._showSaveFilterButton = value;\n    }\n\n    get showLoadFilterButton(): boolean {\n        return this._configuration.showLoadFilterButton ?? this._showLoadFilterButton;\n    }\n\n    @Input() set showLoadFilterButton(value: boolean) {\n        this._showLoadFilterButton = value;\n    }\n\n    get initialSearchMode(): SearchMode {\n        return this._configuration.initialSearchMode ?? this._initialSearchMode;\n    }\n\n    @Input() set initialSearchMode(value: SearchMode) {\n        this._initialSearchMode = value;\n    }\n\n    get showSearchToggleButton(): boolean {\n        return this._configuration.showSearchToggleButton ?? this._showSearchToggleButton;\n    }\n\n    @Input() set showSearchToggleButton(value: boolean) {\n        this._showSearchToggleButton = value;\n    }\n\n    public hasPredicates(): boolean {\n        return Array.from(this._searchService.rootPredicate.getPredicateMap().values()).some(value => value.isVisible);\n    }\n\n    public toggleSearchMode(): void {\n        if (this.advancedSearchDisplayed) {\n            this._searchService.clearPredicates();\n        } else {\n            this._searchService.clearFullTextFilter();\n        }\n\n        this.advancedSearchDisplayed = !this.advancedSearchDisplayed;\n    }\n\n    public showHelp(): void {\n        this._dialogService.openAlertDialog(this._translate.instant('search.help.title'), this._translate.instant('search.help.text'));\n    }\n\n    /**\n     * The saved filter data are emitted into the [filterSaved]{@link AbstractSearchComponent#filterSaved} `EventEmitter`\n     */\n    public saveFilter(): void {\n        this._userFilterService.save(\n            this._searchService,\n            this._allowedNetsService.allowedNetsIdentifiers,\n            this._searchCategories,\n            this._viewIdService.viewId,\n            this.additionalFilterData,\n            this._configuration.saveFilterWithDefaultCategories ?? true,\n            this._configuration.inheritAllowedNets ?? true,\n            this._navigationItemTaskData).subscribe(savedFilterData => {\n                if (savedFilterData) {\n                    this.filterSaved.emit(savedFilterData);\n                }\n        });\n    }\n\n    /**\n     * The loaded filter data are emitted into the [filterLoaded]{@link AbstractSearchComponent#filterLoaded} `EventEmitter`\n     */\n    public loadFilter(): void {\n        this._userFilterService.load(this._searchService.filterType, this._filtersFilter ?? undefined).subscribe(savedFilterData => {\n            if (savedFilterData) {\n                this.filterLoaded.emit(savedFilterData);\n            }\n        });\n    }\n}\n"]}

package/esm2015/lib/search/search-configuration-input-component/abstract-search-configuration-input.component.js

@@ -0,0 +1,75 @@
+import { Input, ViewChild } from '@angular/core';
+export class AbstractSearchConfigurationInputComponent {
+    constructor() {
+        /**
+         * Whether the contents displayed in this component can be edited by the user or not.
+         *
+         * Defaults to `true`
+         */
+        this.editable = true;
+        this.trackByTemplateParts = (a, b) => this._trackByTemplateParts(a, b);
+        /**
+         * 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 = (option) => this._renderSelection(option);
+        this.filterOptions = userInput => {
+            return this.selectedCategory.filterOptions(userInput);
+        };
+    }
+    set configurationInput(input) {
+        // TODO 20.1.2021 BUG - if multiple configuration inputs are displayed at the same time all of them will be focused.
+        //  The same fix as in OperandInputs can be applied here as well.
+        if (input) {
+            setTimeout(() => {
+                if (input.nativeElement !== undefined) {
+                    const ref = input;
+                    ref.nativeElement.focus();
+                }
+                else {
+                    const select = input;
+                    select.focus();
+                    select.open();
+                }
+            });
+        }
+    }
+    clearConfigurationInput() {
+        if (!this.editable) {
+            return;
+        }
+        this.configuration.clear();
+    }
+    clearOperatorInput() {
+        if (!this.editable) {
+            return;
+        }
+        this.selectedCategory.clearOperatorSelection();
+    }
+    /**
+     * Function for tracking Template parts in ngFor.
+     * @param index index of the ngFor element
+     * @param item template part
+     */
+    _trackByTemplateParts(index, item) {
+        return item.id;
+    }
+    /**
+     * 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
+     */
+    _renderSelection(option) {
+        return option ? option.text : '';
+    }
+}
+AbstractSearchConfigurationInputComponent.propDecorators = {
+    editable: [{ type: Input }],
+    configuration: [{ type: Input }],
+    selectedCategory: [{ type: Input }],
+    configurationInput: [{ type: ViewChild, args: ['configurationInput',] }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/search/search-keyword-resolver-service/search-index-resolver.service.js

@@ -0,0 +1,36 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * A utility service that aims to provide elasticsearch query string query index names for data set queries.
+ *
+ * If your app uses a customised elasticsearch database mapping for Case objects, that affects the way data fields are indexed you must
+ * provide an updated version of this service, so that search can generate correct queries.
+ *
+ * You are encouraged to use this service when creating {@link Filter}s, with elastic query string queries, so that future changes to the
+ * default mapping don't affect your existing code.
+ */
+export class SearchIndexResolverService {
+    constructor() { }
+    /**
+     * Constructs the index name for the specified field.
+     *
+     * Note that almost all combinations are valid and will not throw an error when used to query the database, but not all combinations are
+     * used by the application engine. The {@link SearchIndex} class has some information about which field types map to which indices, but
+     * you should consult the backend documentation for more reliable information.
+     * @param dataFieldIdentifier import ID of the queried data field
+     * @param index the queried index
+     * @param keyword whether the keyword of a TEXT index should be queried
+     * @returns the full name of the specified index
+     */
+    getIndex(dataFieldIdentifier, index, keyword = false) {
+        return `dataSet.${dataFieldIdentifier}.${index}${keyword ? '.keyword' : ''}`;
+    }
+}
+SearchIndexResolverService.ɵprov = i0.ɵɵdefineInjectable({ factory: function SearchIndexResolverService_Factory() { return new SearchIndexResolverService(); }, token: SearchIndexResolverService, providedIn: "root" });
+SearchIndexResolverService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+SearchIndexResolverService.ctorParameters = () => [];
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,97 @@
+import { Input, ViewChild } from '@angular/core';
+import { SearchInputType } from '../models/category/search-input-type';
+import { debounceTime } from 'rxjs/operators';
+export class AbstractSearchOperandInputComponent {
+    constructor() {
+        /**
+         * 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 = (selection) => this._renderSelection(selection);
+    }
+    ngOnInit() {
+        if (this.inputType === SearchInputType.AUTOCOMPLETE) {
+            this._autocompleteChange = this.inputFormControl.valueChanges.subscribe(val => {
+                setTimeout(() => {
+                    this._inputConfirmed = !!val && (typeof val !== 'string');
+                });
+            });
+        }
+        if (this.isInputValueSet()) {
+            this._inputConfirmed = true;
+        }
+    }
+    ngOnDestroy() {
+        if (this._autocompleteChange && !this._autocompleteChange.closed) {
+            this._autocompleteChange.unsubscribe();
+        }
+    }
+    get filteredOptions$() {
+        if (!this._filteredOptions$) {
+            this._filteredOptions$ = this.filterOptionsFunction(this.inputFormControl.valueChanges.pipe(debounceTime(600)));
+        }
+        return this._filteredOptions$;
+    }
+    get isInputFilled() {
+        if (!this._inputConfirmed) {
+            return false;
+        }
+        return this.isInputValueSet();
+    }
+    set categoryInput(input) {
+        if (input) {
+            if (!this.first && this._initialExpansion) {
+                this._initialExpansion = false;
+                return;
+            }
+            this._initialExpansion = false;
+            if (!this.isInputFilled) {
+                setTimeout(() => {
+                    input.nativeElement.focus();
+                });
+            }
+        }
+    }
+    confirmInput() {
+        this._inputConfirmed = true;
+    }
+    editInput() {
+        if (!this.editable) {
+            return;
+        }
+        this._inputConfirmed = false;
+    }
+    /**
+     * Autocomplete `displayWith` function
+     * @param selection the selected option
+     */
+    _renderSelection(selection) {
+        return selection ? selection.text : '';
+    }
+    isInputValueSet() {
+        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',] }]
+};
+//# 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/esm2015/lib/search/search-predicate-component/abstract-search-predicate.component.js

@@ -0,0 +1,144 @@
+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.
+ */
+export class AbstractSearchPredicateComponent {
+    constructor(_naeSearchCategories, _logger, _initializationService, _categoryFactory) {
+        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 = (option) => this._renderSelection(option);
+    }
+    ngOnInit() {
+        let found = false;
+        this._searchCategories = this._naeSearchCategories.map(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(() => {
+            if (!!this._selectedCategory) {
+                return this._selectedCategory.createMetadata();
+            }
+            return undefined;
+        });
+        this.predicate.setFilterTextSegmentsGenerator(() => {
+            if (!!this._selectedCategory) {
+                return this._selectedCategory.createFilterTextSegments();
+            }
+            return [];
+        });
+    }
+    ngOnDestroy() {
+        if (this._predicateChange && !this._predicateChange.closed) {
+            this._predicateChange.unsubscribe();
+        }
+        this._searchCategories.forEach(cat => {
+            if (cat !== this.generator) {
+                cat.destroy();
+            }
+        });
+    }
+    get searchCategories() {
+        return this._searchCategories;
+    }
+    set categoryInput(input) {
+        if (input && this._initializationService.isInitialized) {
+            setTimeout(() => {
+                input.focus();
+                input.open();
+            });
+        }
+    }
+    get selectedCategory() {
+        return this._selectedCategory;
+    }
+    set selectedCategory(newCategory) {
+        this.categoryChanged(newCategory);
+    }
+    remove() {
+        this.remove$.next(this.predicateId);
+    }
+    categoryChanged(newCategory) {
+        if (this.selectedCategory !== undefined) {
+            this.selectedCategory.reset();
+        }
+        this._selectedCategory = newCategory;
+        if (newCategory !== undefined) {
+            if (this._predicateChange) {
+                this._predicateChange.unsubscribe();
+            }
+            this._predicateChange = newCategory.generatedPredicate$.subscribe(predicate => this.processPredicateChange(predicate));
+        }
+    }
+    clearCategorySelection() {
+        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
+     */
+    _renderSelection(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`
+     */
+    processPredicateChange(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 = () => [
+    { 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',] }]
+};
+//# 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"]}