@hmcts/ccd-case-ui-toolkit 5.0.3-angular11-upgrade → 5.0.4-angular11-upgrade

package/dist/ccd-case-ui-toolkit/esm2015/lib/shared/components/search-filters/search-filters.component.js

@@ -0,0 +1,296 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { tap } from 'rxjs/operators';
+import { FieldsUtils } from '../../services/fields/fields.utils';
+import { JurisdictionService } from '../../services/jurisdiction/jurisdiction.service';
+import { OrderService } from '../../services/order/order.service';
+import { SearchService } from '../../services/search/search.service';
+import { WindowService } from '../../services/window/window.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/search/search.service";
+import * as i2 from "../../services/order/order.service";
+import * as i3 from "../../services/jurisdiction/jurisdiction.service";
+import * as i4 from "../../services/window/window.service";
+import * as i5 from "@angular/forms";
+import * as i6 from "@angular/common";
+import * as i7 from "../../directives/conditional-show/conditional-show-form.directive";
+import * as i8 from "../palette/base-field/field-write.component";
+function SearchFiltersComponent_option_7_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "option", 12);
+    i0.ɵɵtext(1);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const j_r3 = ctx.$implicit;
+    i0.ɵɵproperty("ngValue", j_r3);
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate(j_r3.name);
+} }
+function SearchFiltersComponent_option_12_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "option", 12);
+    i0.ɵɵtext(1);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ct_r4 = ctx.$implicit;
+    i0.ɵɵproperty("ngValue", ct_r4);
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate(ct_r4.name);
+} }
+function SearchFiltersComponent_ng_container_13_div_2_Template(rf, ctx) { if (rf & 1) {
+    const _r8 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "div", 6);
+    i0.ɵɵelementStart(1, "ccd-field-write", 16);
+    i0.ɵɵlistener("keyup.enter", function SearchFiltersComponent_ng_container_13_div_2_Template_ccd_field_write_keyup_enter_1_listener() { i0.ɵɵrestoreView(_r8); const ctx_r7 = i0.ɵɵnextContext(2); return ctx_r7.apply(); });
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const searchInput_r6 = ctx.$implicit;
+    const ctx_r5 = i0.ɵɵnextContext(2);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("caseField", searchInput_r6.field)("formGroup", ctx_r5.formGroup)("isExpanded", true);
+} }
+function SearchFiltersComponent_ng_container_13_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainerStart(0, 13);
+    i0.ɵɵelementStart(1, "div", 14);
+    i0.ɵɵtemplate(2, SearchFiltersComponent_ng_container_13_div_2_Template, 2, 3, "div", 15);
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const ctx_r2 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("formGroup", ctx_r2.formGroup)("contextFields", ctx_r2.caseFields);
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("ngForOf", ctx_r2.searchInputs);
+} }
+const JURISDICTION_LOC_STORAGE = 'search-jurisdiction';
+const META_FIELDS_LOC_STORAGE = 'search-metadata-fields';
+const FORM_GROUP_VALUE_LOC_STORAGE = 'search-form-group-value';
+const CASE_TYPE_LOC_STORAGE = 'search-caseType';
+export class SearchFiltersComponent {
+    constructor(searchService, orderService, jurisdictionService, windowService) {
+        this.searchService = searchService;
+        this.orderService = orderService;
+        this.jurisdictionService = jurisdictionService;
+        this.windowService = windowService;
+        this.PARAM_JURISDICTION = 'jurisdiction';
+        this.PARAM_CASE_TYPE = 'case-type';
+        this.PARAM_CASE_STATE = 'case-state';
+        this.onApply = new EventEmitter();
+        this.onReset = new EventEmitter();
+        this.onJurisdiction = new EventEmitter();
+        this.formGroup = new FormGroup({});
+    }
+    ngOnInit() {
+        this.selected = {};
+        const jurisdiction = this.windowService.getLocalStorage(JURISDICTION_LOC_STORAGE);
+        if (this.jurisdictions.length === 1 || jurisdiction) {
+            this.selected.jurisdiction = this.jurisdictions[0];
+            if (jurisdiction) {
+                const localStorageJurisdiction = JSON.parse(jurisdiction);
+                this.selected.jurisdiction = this.jurisdictions.filter(j => j.id === localStorageJurisdiction.id)[0];
+            }
+            this.onJurisdictionIdChange();
+        }
+        this.selected.formGroup = this.formGroup;
+        this.selected.page = 1;
+        this.selected.metadataFields = this.getMetadataFields();
+        this.onApply.emit({
+            selected: this.selected,
+            queryParams: this.getQueryParams()
+        });
+    }
+    reset() {
+        this.windowService.removeLocalStorage(FORM_GROUP_VALUE_LOC_STORAGE);
+        this.windowService.removeLocalStorage(CASE_TYPE_LOC_STORAGE);
+        this.windowService.removeLocalStorage(JURISDICTION_LOC_STORAGE);
+        this.windowService.removeLocalStorage(META_FIELDS_LOC_STORAGE);
+        this.selected = {};
+        if (this.jurisdictions.length === 1) {
+            this.selected.jurisdiction = this.jurisdictions[0];
+            this.onJurisdictionIdChange();
+        }
+        this.onReset.emit();
+    }
+    apply() {
+        this.selected.formGroup = this.formGroup;
+        this.selected.page = 1;
+        this.selected.metadataFields = this.getMetadataFields();
+        this.populateValuesInLocalStorage();
+        this.onApply.emit({
+            selected: this.selected,
+            queryParams: this.getQueryParams()
+        });
+        this.setFocusToTop();
+    }
+    populateValuesInLocalStorage() {
+        this.windowService.setLocalStorage(FORM_GROUP_VALUE_LOC_STORAGE, JSON.stringify(this.selected.formGroup.value));
+        this.windowService.setLocalStorage(META_FIELDS_LOC_STORAGE, JSON.stringify(this.selected.metadataFields));
+        this.windowService.setLocalStorage(JURISDICTION_LOC_STORAGE, JSON.stringify(this.selected.jurisdiction));
+        if (this.selected.caseType) {
+            this.windowService.setLocalStorage(CASE_TYPE_LOC_STORAGE, JSON.stringify(this.selected.caseType));
+        }
+    }
+    getMetadataFields() {
+        if (this.searchInputs) {
+            return this.searchInputs
+                .filter(searchInput => searchInput.field.metadata === true)
+                .map(searchInput => searchInput.field.id);
+        }
+    }
+    isSearchable() {
+        let result;
+        result = this.selected.jurisdiction !== undefined && this.selected.jurisdiction !== null;
+        result = result && this.selected.caseType !== undefined && this.selected.caseType !== null;
+        return result;
+    }
+    isSearchableAndSearchInputsReady() {
+        return this.isSearchable() && this.searchInputsReady;
+    }
+    onJurisdictionIdChange() {
+        this.selected.caseType = null;
+        this.jurisdictionService.announceSelectedJurisdiction(this.selected.jurisdiction);
+        this.selectedJurisdictionCaseTypes = this.selected.jurisdiction.caseTypes;
+        this.selectCaseType(this.selectedJurisdictionCaseTypes);
+        this.onJurisdiction.emit(this.selected.jurisdiction);
+    }
+    onCaseTypeIdChange() {
+        this.formGroup = new FormGroup({});
+        this.searchInputsReady = false;
+        this.searchInputs = [];
+        this.searchService.getSearchInputs(this.selected.jurisdiction.id, this.selected.caseType.id).pipe(tap(() => this.searchInputsReady = true)).subscribe(searchInputs => {
+            this.searchInputs = searchInputs.sort(this.orderService.sortAsc);
+            const formValue = this.windowService.getLocalStorage(FORM_GROUP_VALUE_LOC_STORAGE);
+            let formValueObject = null;
+            if (formValue) {
+                formValueObject = JSON.parse(formValue);
+            }
+            searchInputs.forEach(item => {
+                if (item.field.elementPath) {
+                    item.field.id = item.field.id + '.' + item.field.elementPath;
+                }
+                item.field.label = item.label;
+                if (formValueObject) {
+                    item.field.value = formValueObject[item.field.id];
+                }
+            });
+            this.getCaseFields();
+        }, error => {
+            console.log('Search input fields request will be discarded reason: ', error.message);
+        });
+    }
+    isJurisdictionSelected() {
+        return this.selected.jurisdiction === null ||
+            this.selected.jurisdiction === undefined;
+    }
+    getQueryParams() {
+        // Save filters as query parameters for current route
+        const queryParams = {};
+        if (this.selected.jurisdiction) {
+            queryParams[this.PARAM_JURISDICTION] = this.selected.jurisdiction.id;
+        }
+        if (this.selected.caseType) {
+            queryParams[this.PARAM_CASE_TYPE] = this.selected.caseType.id;
+        }
+        if (this.selected.caseState) {
+            queryParams[this.PARAM_CASE_STATE] = this.selected.caseState.id;
+        }
+        return queryParams;
+    }
+    selectCaseType(caseTypes) {
+        if (caseTypes && caseTypes.length > 0) {
+            this.selected.caseType = caseTypes[0];
+            const caseType = this.windowService.getLocalStorage(CASE_TYPE_LOC_STORAGE);
+            if (caseType) {
+                const caseTypeObject = JSON.parse(caseType);
+                const result = caseTypes.filter(c => c.id === caseTypeObject.id);
+                if (result !== undefined && result.length > 0) {
+                    this.selected.caseType = result[0];
+                }
+                else {
+                    this.selected.caseType = caseTypes[0];
+                }
+            }
+            else {
+                this.selected.caseType = caseTypes[0];
+            }
+            this.onCaseTypeIdChange();
+        }
+    }
+    setFocusToTop() {
+        window.scrollTo(0, 0);
+        const topContainer = document.getElementById('search-result-heading__text');
+        if (topContainer) {
+            topContainer.focus();
+        }
+    }
+    getCaseFields() {
+        if (this.searchInputs) {
+            this.caseFields = this.searchInputs.map(item => FieldsUtils.convertToCaseField(item.field));
+        }
+    }
+}
+SearchFiltersComponent.ɵfac = function SearchFiltersComponent_Factory(t) { return new (t || SearchFiltersComponent)(i0.ɵɵdirectiveInject(i1.SearchService), i0.ɵɵdirectiveInject(i2.OrderService), i0.ɵɵdirectiveInject(i3.JurisdictionService), i0.ɵɵdirectiveInject(i4.WindowService)); };
+SearchFiltersComponent.ɵcmp = i0.ɵɵdefineComponent({ type: SearchFiltersComponent, selectors: [["ccd-search-filters"]], inputs: { jurisdictions: "jurisdictions", autoApply: "autoApply" }, outputs: { onApply: "onApply", onReset: "onReset", onJurisdiction: "onJurisdiction" }, decls: 19, vars: 7, consts: [["aria-label", "Filters", 1, "heading-h2"], [1, "global-display"], [1, "form-group", 2, "margin-top", "13px"], ["for", "s-jurisdiction", 1, "form-label"], ["id", "s-jurisdiction", "name", "jurisdiction", "aria-controls", "search-result", 1, "form-control", "form-control-3-4", "ccd-dropdown", 3, "ngModel", "ngModelChange", "change"], [3, "ngValue", 4, "ngFor", "ngForOf"], [1, "form-group"], ["for", "s-case-type", 1, "form-label"], ["id", "s-case-type", "name", "case-type", "aria-controls", "search-result", 1, "form-control", "form-control-3-4", "ccd-dropdown", 3, "disabled", "ngModel", "ngModelChange", "change"], ["ccdConditionalShowForm", "", 3, "formGroup", "contextFields", 4, "ngIf"], ["type", "button", "title", "Apply filter", "aria-label", "Apply filter", 1, "button", 3, "disabled", "click", "keyup.enter"], ["id", "reset", "type", "button", "title", "Reset filter", "aria-label", "Reset filter", 1, "button", "button-secondary", 3, "click"], [3, "ngValue"], ["ccdConditionalShowForm", "", 3, "formGroup", "contextFields"], ["id", "dynamicFilters"], ["class", "form-group", 4, "ngFor", "ngForOf"], [3, "caseField", "formGroup", "isExpanded", "keyup.enter"]], template: function SearchFiltersComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵelementStart(0, "h2", 0);
+        i0.ɵɵtext(1, "Filters");
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementStart(2, "form", 1);
+        i0.ɵɵelementStart(3, "div", 2);
+        i0.ɵɵelementStart(4, "label", 3);
+        i0.ɵɵtext(5, "Jurisdiction*");
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementStart(6, "select", 4);
+        i0.ɵɵlistener("ngModelChange", function SearchFiltersComponent_Template_select_ngModelChange_6_listener($event) { return ctx.selected.jurisdiction = $event; })("change", function SearchFiltersComponent_Template_select_change_6_listener() { return ctx.onJurisdictionIdChange(); });
+        i0.ɵɵtemplate(7, SearchFiltersComponent_option_7_Template, 2, 2, "option", 5);
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementStart(8, "div", 6);
+        i0.ɵɵelementStart(9, "label", 7);
+        i0.ɵɵtext(10, "Case type*");
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementStart(11, "select", 8);
+        i0.ɵɵlistener("ngModelChange", function SearchFiltersComponent_Template_select_ngModelChange_11_listener($event) { return ctx.selected.caseType = $event; })("change", function SearchFiltersComponent_Template_select_change_11_listener() { return ctx.onCaseTypeIdChange(); });
+        i0.ɵɵtemplate(12, SearchFiltersComponent_option_12_Template, 2, 2, "option", 5);
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+        i0.ɵɵtemplate(13, SearchFiltersComponent_ng_container_13_Template, 3, 3, "ng-container", 9);
+        i0.ɵɵelementStart(14, "button", 10);
+        i0.ɵɵlistener("click", function SearchFiltersComponent_Template_button_click_14_listener() { return ctx.apply(); })("keyup.enter", function SearchFiltersComponent_Template_button_keyup_enter_14_listener() { return ctx.apply(); });
+        i0.ɵɵtext(15, "Apply");
+        i0.ɵɵelementEnd();
+        i0.ɵɵtext(16, " \u00A0\u00A0\u00A0 ");
+        i0.ɵɵelementStart(17, "button", 11);
+        i0.ɵɵlistener("click", function SearchFiltersComponent_Template_button_click_17_listener() { return ctx.reset(); });
+        i0.ɵɵtext(18, "Reset");
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+    } if (rf & 2) {
+        i0.ɵɵadvance(6);
+        i0.ɵɵproperty("ngModel", ctx.selected.jurisdiction);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngForOf", ctx.jurisdictions);
+        i0.ɵɵadvance(4);
+        i0.ɵɵproperty("disabled", ctx.isJurisdictionSelected())("ngModel", ctx.selected.caseType);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngForOf", ctx.selectedJurisdictionCaseTypes);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngIf", ctx.isSearchableAndSearchInputsReady());
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("disabled", !ctx.isSearchableAndSearchInputsReady());
+    } }, directives: [i5.ɵangular_packages_forms_forms_ba, i5.NgControlStatusGroup, i5.NgForm, i5.SelectControlValueAccessor, i5.NgControlStatus, i5.NgModel, i6.NgForOf, i6.NgIf, i5.NgSelectOption, i5.ɵangular_packages_forms_forms_z, i7.ConditionalShowFormDirective, i5.FormGroupDirective, i8.FieldWriteComponent], encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SearchFiltersComponent, [{
+        type: Component,
+        args: [{
+                selector: 'ccd-search-filters',
+                templateUrl: './search-filters.component.html',
+            }]
+    }], function () { return [{ type: i1.SearchService }, { type: i2.OrderService }, { type: i3.JurisdictionService }, { type: i4.WindowService }]; }, { jurisdictions: [{
+            type: Input
+        }], autoApply: [{
+            type: Input
+        }], onApply: [{
+            type: Output
+        }], onReset: [{
+            type: Output
+        }], onJurisdiction: [{
+            type: Output
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search-filters.component.js","sourceRoot":"","sources":["../../../../../../../projects/ccd-case-ui-toolkit/src/lib/shared/components/search-filters/search-filters.component.ts","../../../../../../../projects/ccd-case-ui-toolkit/src/lib/shared/components/search-filters/search-filters.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, OnInit, Output } from '@angular/core';\nimport { FormGroup } from '@angular/forms';\nimport { tap } from 'rxjs/operators';\n\nimport { CaseField } from '../../domain/definition/case-field.model';\nimport { CaseState } from '../../domain/definition/case-state.model';\nimport { CaseTypeLite } from '../../domain/definition/case-type-lite.model';\nimport { Jurisdiction } from '../../domain/definition/jurisdiction.model';\nimport { FieldsUtils } from '../../services/fields/fields.utils';\nimport { JurisdictionService } from '../../services/jurisdiction/jurisdiction.service';\nimport { OrderService } from '../../services/order/order.service';\nimport { SearchService } from '../../services/search/search.service';\nimport { WindowService } from '../../services/window/window.service';\nimport { SearchInput } from './domain/search-input.model';\n\nconst JURISDICTION_LOC_STORAGE = 'search-jurisdiction';\nconst META_FIELDS_LOC_STORAGE = 'search-metadata-fields';\nconst FORM_GROUP_VALUE_LOC_STORAGE = 'search-form-group-value';\nconst CASE_TYPE_LOC_STORAGE = 'search-caseType';\n@Component({\n  selector: 'ccd-search-filters',\n  templateUrl: './search-filters.component.html',\n})\n\nexport class SearchFiltersComponent implements OnInit {\n  public readonly PARAM_JURISDICTION = 'jurisdiction';\n  public readonly PARAM_CASE_TYPE = 'case-type';\n  public readonly PARAM_CASE_STATE = 'case-state';\n  public caseFields: CaseField[];\n\n  @Input()\n  public jurisdictions: Jurisdiction[];\n\n  @Input()\n  public autoApply: boolean;\n\n  @Output()\n  public onApply: EventEmitter<any> = new EventEmitter();\n\n  @Output()\n  public onReset: EventEmitter<any> = new EventEmitter();\n\n  @Output()\n  public onJurisdiction: EventEmitter<any> = new EventEmitter();\n\n  public searchInputs: SearchInput[];\n  public searchInputsReady: boolean;\n\n  public selected: {\n    jurisdiction?: Jurisdiction,\n    caseType?: CaseTypeLite,\n    formGroup?: FormGroup,\n    caseState?: CaseState,\n    page?: number,\n    metadataFields?: string[]\n  };\n\n  public selectedJurisdictionCaseTypes?: CaseTypeLite[];\n\n  public formGroup: FormGroup = new FormGroup({});\n\n  constructor(private readonly searchService: SearchService,\n    private readonly orderService: OrderService,\n    private readonly jurisdictionService: JurisdictionService,\n    private readonly windowService: WindowService) {\n  }\n\n  public ngOnInit(): void {\n    this.selected = {};\n    const jurisdiction = this.windowService.getLocalStorage(JURISDICTION_LOC_STORAGE);\n    if (this.jurisdictions.length === 1 || jurisdiction) {\n      this.selected.jurisdiction = this.jurisdictions[0];\n      if (jurisdiction) {\n        const localStorageJurisdiction = JSON.parse(jurisdiction);\n        this.selected.jurisdiction = this.jurisdictions.filter(j => j.id === localStorageJurisdiction.id)[0];\n      }\n      this.onJurisdictionIdChange();\n    }\n\n    this.selected.formGroup = this.formGroup;\n    this.selected.page = 1;\n    this.selected.metadataFields = this.getMetadataFields();\n    this.onApply.emit({\n      selected: this.selected,\n      queryParams: this.getQueryParams()\n    });\n\n  }\n\n  public reset(): void {\n    this.windowService.removeLocalStorage(FORM_GROUP_VALUE_LOC_STORAGE);\n    this.windowService.removeLocalStorage(CASE_TYPE_LOC_STORAGE);\n    this.windowService.removeLocalStorage(JURISDICTION_LOC_STORAGE);\n    this.windowService.removeLocalStorage(META_FIELDS_LOC_STORAGE);\n    this.selected = {};\n    if (this.jurisdictions.length === 1) {\n      this.selected.jurisdiction = this.jurisdictions[0];\n      this.onJurisdictionIdChange();\n    }\n    this.onReset.emit();\n  }\n\n  public apply(): void {\n    this.selected.formGroup = this.formGroup;\n    this.selected.page = 1;\n    this.selected.metadataFields = this.getMetadataFields();\n    this.populateValuesInLocalStorage();\n    this.onApply.emit({\n      selected: this.selected,\n      queryParams: this.getQueryParams()\n    });\n    this.setFocusToTop();\n  }\n\n  public populateValuesInLocalStorage(): void {\n    this.windowService.setLocalStorage(FORM_GROUP_VALUE_LOC_STORAGE,\n      JSON.stringify(this.selected.formGroup.value));\n    this.windowService.setLocalStorage(META_FIELDS_LOC_STORAGE, JSON.stringify(this.selected.metadataFields));\n    this.windowService.setLocalStorage(JURISDICTION_LOC_STORAGE, JSON.stringify(this.selected.jurisdiction));\n    if (this.selected.caseType) {\n      this.windowService.setLocalStorage(CASE_TYPE_LOC_STORAGE, JSON.stringify(this.selected.caseType));\n    }\n  }\n\n  public getMetadataFields(): string[] {\n    if (this.searchInputs) {\n      return this.searchInputs\n        .filter(searchInput => searchInput.field.metadata === true)\n        .map(searchInput => searchInput.field.id);\n    }\n  }\n\n  public isSearchable(): boolean {\n    let result: boolean;\n    result = this.selected.jurisdiction !== undefined && this.selected.jurisdiction !== null;\n    result = result && this.selected.caseType !== undefined && this.selected.caseType !== null;\n    return result;\n  }\n\n  public isSearchableAndSearchInputsReady(): boolean {\n    return this.isSearchable() && this.searchInputsReady;\n  }\n\n  public onJurisdictionIdChange(): void {\n    this.selected.caseType = null;\n    this.jurisdictionService.announceSelectedJurisdiction(this.selected.jurisdiction);\n    this.selectedJurisdictionCaseTypes = this.selected.jurisdiction.caseTypes;\n    this.selectCaseType(this.selectedJurisdictionCaseTypes);\n    this.onJurisdiction.emit(this.selected.jurisdiction);\n  }\n\n  public onCaseTypeIdChange(): void {\n    this.formGroup = new FormGroup({});\n    this.searchInputsReady = false;\n    this.searchInputs = [];\n    this.searchService.getSearchInputs(\n      this.selected.jurisdiction.id,\n      this.selected.caseType.id\n    ).pipe(\n      tap(() => this.searchInputsReady = true)\n    ).subscribe(searchInputs => {\n        this.searchInputs = searchInputs.sort(this.orderService.sortAsc);\n\n        const formValue = this.windowService.getLocalStorage(FORM_GROUP_VALUE_LOC_STORAGE);\n        let formValueObject = null;\n        if (formValue) {\n          formValueObject = JSON.parse(formValue);\n        }\n        searchInputs.forEach(item => {\n          if (item.field.elementPath) {\n            item.field.id = item.field.id + '.' + item.field.elementPath;\n          }\n          item.field.label = item.label;\n          if (formValueObject) {\n            item.field.value = formValueObject[item.field.id];\n          }\n        });\n        this.getCaseFields();\n      }, error => {\n        console.log('Search input fields request will be discarded reason: ', error.message);\n      });\n  }\n\n  public isJurisdictionSelected(): boolean {\n    return this.selected.jurisdiction === null ||\n      this.selected.jurisdiction === undefined;\n  }\n\n  private getQueryParams() {\n    // Save filters as query parameters for current route\n    const queryParams = {};\n    if (this.selected.jurisdiction) {\n      queryParams[this.PARAM_JURISDICTION] = this.selected.jurisdiction.id;\n    }\n    if (this.selected.caseType) {\n      queryParams[this.PARAM_CASE_TYPE] = this.selected.caseType.id;\n    }\n    if (this.selected.caseState) {\n      queryParams[this.PARAM_CASE_STATE] = this.selected.caseState.id;\n    }\n    return queryParams;\n  }\n\n  private selectCaseType(caseTypes: CaseTypeLite[]) {\n    if (caseTypes && caseTypes.length > 0) {\n      this.selected.caseType = caseTypes[0];\n      const caseType = this.windowService.getLocalStorage(CASE_TYPE_LOC_STORAGE);\n      if (caseType) {\n        const caseTypeObject = JSON.parse(caseType);\n        const result = caseTypes.filter(c => c.id === caseTypeObject.id);\n        if (result !== undefined && result.length > 0) {\n          this.selected.caseType = result[0];\n        } else {\n          this.selected.caseType = caseTypes[0];\n        }\n      } else {\n        this.selected.caseType = caseTypes[0];\n      }\n      this.onCaseTypeIdChange();\n    }\n  }\n\n  private setFocusToTop() {\n    window.scrollTo(0, 0);\n\n    const topContainer = document.getElementById('search-result-heading__text');\n    if (topContainer) {\n      topContainer.focus();\n    }\n  }\n\n  private getCaseFields(): void {\n    if (this.searchInputs) {\n      this.caseFields = this.searchInputs.map(item => FieldsUtils.convertToCaseField(item.field));\n    }\n  }\n}\n","<h2 class=\"heading-h2\" aria-label=\"Filters\">Filters</h2>\n<form class=\"global-display\">\n  <div class=\"form-group\" style=\"margin-top: 13px;\">\n    <label class=\"form-label\" for=\"s-jurisdiction\">Jurisdiction*</label>\n    <select class=\"form-control form-control-3-4 ccd-dropdown\" id=\"s-jurisdiction\"\n            name=\"jurisdiction\" [(ngModel)]=\"selected.jurisdiction\" aria-controls=\"search-result\"\n            (change)=\"onJurisdictionIdChange()\">\n      <option *ngFor=\"let j of jurisdictions\" [ngValue]=\"j\">{{j.name}}</option>\n    </select>\n  </div>\n\n  <div class=\"form-group\">\n    <label class=\"form-label\" for=\"s-case-type\">Case type*</label>\n    <select [disabled]=\"isJurisdictionSelected()\" class=\"form-control form-control-3-4 ccd-dropdown\"\n            id=\"s-case-type\" name=\"case-type\" [(ngModel)]=\"selected.caseType\" aria-controls=\"search-result\"\n            (change)=\"onCaseTypeIdChange()\">\n      <option *ngFor=\"let ct of selectedJurisdictionCaseTypes\" [ngValue]=\"ct\">{{ct.name}}</option>\n    </select>\n  </div>\n\n  <ng-container ccdConditionalShowForm *ngIf=\"isSearchableAndSearchInputsReady()\" [formGroup]=\"formGroup\" [contextFields]=\"caseFields\">\n    <div id=\"dynamicFilters\">\n      <div class=\"form-group\" *ngFor=\"let searchInput of searchInputs\">\n        <ccd-field-write [caseField]=\"searchInput.field\" [formGroup]=\"formGroup\" [isExpanded]=\"true\" (keyup.enter)=\"apply()\"></ccd-field-write>\n      </div>\n    </div>\n  </ng-container>\n\n  <button [disabled]=\"!isSearchableAndSearchInputsReady()\" type=\"button\" class=\"button\" (click)=\"apply()\" (keyup.enter)=\"apply()\" title=\"Apply filter\" aria-label=\"Apply filter\">Apply</button> &nbsp;&nbsp;&nbsp;\n  <button id=\"reset\" type=\"button\" (click)=\"reset()\" class=\"button button-secondary\" title=\"Reset filter\" aria-label=\"Reset filter\">Reset</button>\n</form>\n"]}

package/dist/ccd-case-ui-toolkit/esm2015/lib/shared/components/search-filters/search-filters.module.js

@@ -0,0 +1,65 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { ConditionalShowModule } from '../../directives/conditional-show/conditional-show.module';
+import { DefinitionsService } from '../../services/definitions/definitions.service';
+import { JurisdictionService } from '../../services/jurisdiction/jurisdiction.service';
+import { OrderService } from '../../services/order/order.service';
+import { SearchService } from '../../services/search/search.service';
+import { WindowService } from '../../services/window/window.service';
+import { PaletteModule } from '../palette/palette.module';
+import { SearchFiltersWrapperComponent } from './search-filters-wrapper.component';
+import { SearchFiltersComponent } from './search-filters.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class SearchFiltersModule {
+}
+SearchFiltersModule.ɵfac = function SearchFiltersModule_Factory(t) { return new (t || SearchFiltersModule)(); };
+SearchFiltersModule.ɵmod = i0.ɵɵdefineNgModule({ type: SearchFiltersModule });
+SearchFiltersModule.ɵinj = i0.ɵɵdefineInjector({ providers: [
+        SearchService,
+        OrderService,
+        JurisdictionService,
+        DefinitionsService,
+        WindowService
+    ], imports: [[
+            CommonModule,
+            FormsModule,
+            ReactiveFormsModule,
+            PaletteModule,
+            ConditionalShowModule
+        ]] });
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(SearchFiltersModule, { declarations: [SearchFiltersComponent,
+        SearchFiltersWrapperComponent], imports: [CommonModule,
+        FormsModule,
+        ReactiveFormsModule,
+        PaletteModule,
+        ConditionalShowModule], exports: [SearchFiltersWrapperComponent] }); })();
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SearchFiltersModule, [{
+        type: NgModule,
+        args: [{
+                imports: [
+                    CommonModule,
+                    FormsModule,
+                    ReactiveFormsModule,
+                    PaletteModule,
+                    ConditionalShowModule
+                ],
+                declarations: [
+                    SearchFiltersComponent,
+                    SearchFiltersWrapperComponent
+                ],
+                exports: [
+                    SearchFiltersWrapperComponent
+                ],
+                providers: [
+                    SearchService,
+                    OrderService,
+                    JurisdictionService,
+                    DefinitionsService,
+                    WindowService
+                ]
+            }]
+    }], null, null); })();
+i0.ɵɵsetComponentScope(SearchFiltersWrapperComponent, [i1.NgIf, SearchFiltersComponent], []);
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ccd-case-ui-toolkit/esm2015/lib/shared/directives/conditional-show/conditional-show-form.directive.js

@@ -0,0 +1,164 @@
+import { Directive, Input } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { debounceTime } from 'rxjs/operators';
+import { AbstractFieldWriteComponent } from '../../components/palette/base-field/abstract-field-write.component';
+import { FieldsUtils } from '../../services/fields/fields.utils';
+import { ShowCondition } from './domain/conditional-show.model';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/fields/fields.utils";
+/** Hides and shows all fields in a form. Works on read only fields and form fields.
+ *  The show condition is evaluated on all the fields of the page. i.e. read only and form fields.
+ *  Evaluation of the show condition includes disabled fields, which can be on their initial value or empty. Executes on the
+ *  host field initialization and when any field of the form changes.
+ *  Collaborates with the GreyBarService to show a vertical grey bar when a field initially hidden on the page is shown. When returning
+ *  to the page after the page has been left, the grey bar has to be redisplayed. If instead on initial page load the field renders as
+ *  initially shown, the grey bar is not displayed.
+ */
+export class ConditionalShowFormDirective {
+    constructor(fieldsUtils) {
+        this.fieldsUtils = fieldsUtils;
+        this.contextFields = [];
+        // make sure for the 3 callbacks that we are bound to this via an arrow function
+        this.handleFormControl = (formControl) => {
+            this.evaluateControl(formControl);
+        };
+        this.handleFormArray = (formArray) => {
+            this.evaluateControl(formArray);
+            formArray.controls.forEach(formControl => {
+                this.fieldsUtils.controlIterator(formControl, this.handleFormArray, this.handleFormGroup, this.handleFormControl);
+            });
+        };
+        this.handleFormGroup = (formGroup) => {
+            this.evaluateControl(formGroup);
+            let groupControl = formGroup;
+            if (formGroup.get('value') && formGroup.get('value') instanceof FormGroup) { // Complex Field
+                groupControl = formGroup.get('value');
+            }
+            else if (formGroup.controls) {
+                // Special Fields like AddressUK, AddressGlobal
+                groupControl = formGroup;
+            }
+            if (groupControl.controls) {
+                Object.keys(groupControl.controls).forEach(cKey => {
+                    // EUI-3359.
+                    // Get the control from groupControl.controls[cKey] rather than
+                    // groupControl.get(cKey) as the latter does pathing and will interpret
+                    // full stops in cKey as delimeters for being nested within an array,
+                    // which makes no sense in this situation.
+                    const control = groupControl.controls[cKey];
+                    this.fieldsUtils.controlIterator(control, this.handleFormArray, this.handleFormGroup, this.handleFormControl);
+                });
+            }
+        };
+    }
+    ngOnInit() {
+        if (!this.formGroup) {
+            this.formGroup = new FormGroup({});
+        }
+    }
+    /**
+     * Moved the evaluation of show/hide conditions and subscription
+     * to form changes until after the form has been fully created.
+     *
+     * Prior to this change, I traced more than 5,100,000 firings of
+     * the evaluateCondition INSIDE the show_condition check on page
+     * load for an event with a lot of content. After this change,
+     * that number dropped to fewer than 2,500 - that's a.
+     */
+    ngAfterViewInit() {
+        this.evalAllShowHideConditions();
+        this.subscribeToFormChanges();
+    }
+    ngOnDestroy() {
+        this.unsubscribeFromFormChanges();
+    }
+    /*
+    * Delay the execution of evalShowHideConditions for 100ms
+    * Evaluating showHideConditions on input is inefficient as all forms are evaluated
+    * whilst the user is still typing. We are better off allowing the user to finish typing
+    * then evaluate the show hide conditions.
+    */
+    subscribeToFormChanges() {
+        this.unsubscribeFromFormChanges();
+        this.formChangesSubscription = this.formGroup.valueChanges
+            .pipe(debounceTime(100))
+            .subscribe(_ => {
+            this.evalAllShowHideConditions();
+        });
+    }
+    evaluateControl(control) {
+        const cf = control['caseField'];
+        const component = control['component'];
+        this.evaluateCondition(cf, component, control);
+    }
+    evaluateCondition(cf, component, control) {
+        if (cf) {
+            if (cf.display_context === 'HIDDEN') {
+                cf.hidden = true; // display_context === 'HIDDEN' means always hide
+            }
+            else if (cf.show_condition) {
+                const showCondition = ShowCondition.getInstance(cf.show_condition);
+                const condResult = showCondition.match(this.allFieldValues, this.buildPath(component, cf));
+                if (cf.hidden === null || cf.hidden === undefined) {
+                    cf.hidden = false;
+                }
+                if (condResult === cf.hidden) {
+                    cf.hidden = !condResult;
+                }
+                // EUI-3267. If this field is showing, set the hiddenCannotChange flag.
+                // This is used in the display of the grey bar.
+                if (!cf.hidden) {
+                    cf.hiddenCannotChange = showCondition.hiddenCannotChange(this.caseFields);
+                }
+                // Disable the control if it's hidden so that it doesn't count towards the
+                // validation state of the form, but only if it's actually being validated.
+                if (control.validator) {
+                    if (cf.hidden === true && !control.disabled) {
+                        control.disable({ emitEvent: false });
+                    }
+                    else if (cf.hidden !== true && control.disabled) {
+                        control.enable({ emitEvent: false });
+                    }
+                }
+            }
+        }
+    }
+    evalAllShowHideConditions() {
+        this.getCurrentPagesReadOnlyAndFormFieldValues();
+        this.fieldsUtils.controlIterator(this.formGroup, this.handleFormArray, this.handleFormGroup, this.handleFormControl);
+    }
+    buildPath(c, field) {
+        if (c && c instanceof AbstractFieldWriteComponent) {
+            if (c.idPrefix) {
+                return c.idPrefix + field.id;
+            }
+        }
+        return field.id;
+    }
+    getCurrentPagesReadOnlyAndFormFieldValues() {
+        const formFields = this.getFormFieldsValuesIncludingDisabled();
+        this.allFieldValues = this.fieldsUtils.mergeCaseFieldsAndFormFields(this.contextFields, formFields);
+        return this.allFieldValues;
+    }
+    getFormFieldsValuesIncludingDisabled() {
+        return this.formGroup.getRawValue();
+    }
+    unsubscribeFromFormChanges() {
+        if (this.formChangesSubscription) {
+            this.formChangesSubscription.unsubscribe();
+        }
+    }
+}
+ConditionalShowFormDirective.ɵfac = function ConditionalShowFormDirective_Factory(t) { return new (t || ConditionalShowFormDirective)(i0.ɵɵdirectiveInject(i1.FieldsUtils)); };
+ConditionalShowFormDirective.ɵdir = i0.ɵɵdefineDirective({ type: ConditionalShowFormDirective, selectors: [["", "ccdConditionalShowForm", ""]], inputs: { caseFields: "caseFields", contextFields: "contextFields", formGroup: "formGroup" } });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ConditionalShowFormDirective, [{
+        type: Directive,
+        args: [{ selector: '[ccdConditionalShowForm]' }]
+    }], function () { return [{ type: i1.FieldsUtils }]; }, { caseFields: [{
+            type: Input
+        }], contextFields: [{
+            type: Input
+        }], formGroup: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"conditional-show-form.directive.js","sourceRoot":"","sources":["../../../../../../../projects/ccd-case-ui-toolkit/src/lib/shared/directives/conditional-show/conditional-show-form.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, Directive, Input, OnDestroy, OnInit } from '@angular/core';\nimport { AbstractControl, FormArray, FormControl, FormGroup } from '@angular/forms';\nimport { Subscription } from 'rxjs';\nimport { debounceTime } from 'rxjs/operators';\n\nimport { AbstractFieldWriteComponent } from '../../components/palette/base-field/abstract-field-write.component';\nimport { AbstractFormFieldComponent } from '../../components/palette/base-field/abstract-form-field.component';\nimport { CaseField } from '../../domain/definition/case-field.model';\nimport { FieldsUtils } from '../../services/fields/fields.utils';\nimport { ShowCondition } from './domain/conditional-show.model';\n\n@Directive({ selector: '[ccdConditionalShowForm]' })\n/** Hides and shows all fields in a form. Works on read only fields and form fields.\n *  The show condition is evaluated on all the fields of the page. i.e. read only and form fields.\n *  Evaluation of the show condition includes disabled fields, which can be on their initial value or empty. Executes on the\n *  host field initialization and when any field of the form changes.\n *  Collaborates with the GreyBarService to show a vertical grey bar when a field initially hidden on the page is shown. When returning\n *  to the page after the page has been left, the grey bar has to be redisplayed. If instead on initial page load the field renders as\n *  initially shown, the grey bar is not displayed.\n */\nexport class ConditionalShowFormDirective implements OnInit, AfterViewInit, OnDestroy {\n\n  @Input() public caseFields: CaseField[];\n  @Input() public contextFields: CaseField[] = [];\n  @Input() public formGroup: FormGroup;\n\n  private allFieldValues: any;\n  private formChangesSubscription: Subscription;\n\n  constructor(private readonly fieldsUtils: FieldsUtils) {\n  }\n\n  public ngOnInit() {\n    if (!this.formGroup) {\n      this.formGroup = new FormGroup({});\n    }\n  }\n\n  /**\n   * Moved the evaluation of show/hide conditions and subscription\n   * to form changes until after the form has been fully created.\n   *\n   * Prior to this change, I traced more than 5,100,000 firings of\n   * the evaluateCondition INSIDE the show_condition check on page\n   * load for an event with a lot of content. After this change,\n   * that number dropped to fewer than 2,500 - that's a.\n   */\n  public ngAfterViewInit() {\n    this.evalAllShowHideConditions();\n    this.subscribeToFormChanges();\n  }\n\n  public ngOnDestroy() {\n    this.unsubscribeFromFormChanges();\n  }\n\n  /*\n  * Delay the execution of evalShowHideConditions for 100ms\n  * Evaluating showHideConditions on input is inefficient as all forms are evaluated\n  * whilst the user is still typing. We are better off allowing the user to finish typing\n  * then evaluate the show hide conditions.\n  */\n  private subscribeToFormChanges() {\n    this.unsubscribeFromFormChanges();\n    this.formChangesSubscription = this.formGroup.valueChanges\n      .pipe(\n        debounceTime(100)\n      )\n      .subscribe(_ => {\n      this.evalAllShowHideConditions();\n    });\n  }\n\n  private evaluateControl(control: AbstractControl) {\n    const cf = control['caseField'] as CaseField;\n    const component = control['component'] as AbstractFormFieldComponent;\n    this.evaluateCondition(cf, component, control);\n  }\n\n  private evaluateCondition(cf: CaseField, component: AbstractFormFieldComponent, control: AbstractControl) {\n    if (cf) {\n      if (cf.display_context === 'HIDDEN') {\n        cf.hidden = true; // display_context === 'HIDDEN' means always hide\n      } else if (cf.show_condition) {\n        const showCondition: ShowCondition = ShowCondition.getInstance(cf.show_condition);\n        const condResult = showCondition.match(this.allFieldValues, this.buildPath(component, cf));\n        if (cf.hidden === null || cf.hidden === undefined) {\n          cf.hidden = false;\n        }\n        if (condResult === cf.hidden) {\n          cf.hidden = !condResult;\n        }\n        // EUI-3267. If this field is showing, set the hiddenCannotChange flag.\n        // This is used in the display of the grey bar.\n        if (!cf.hidden) {\n          cf.hiddenCannotChange = showCondition.hiddenCannotChange(this.caseFields);\n        }\n        // Disable the control if it's hidden so that it doesn't count towards the\n        // validation state of the form, but only if it's actually being validated.\n        if (control.validator) {\n          if (cf.hidden === true && !control.disabled) {\n            control.disable({ emitEvent: false });\n          } else if (cf.hidden !== true && control.disabled) {\n            control.enable({ emitEvent: false });\n          }\n        }\n      }\n    }\n  }\n\n  // make sure for the 3 callbacks that we are bound to this via an arrow function\n  private readonly handleFormControl = (formControl: FormControl): void => {\n    this.evaluateControl(formControl);\n  }\n\n  private readonly handleFormArray = (formArray: FormArray): void => {\n    this.evaluateControl(formArray);\n    formArray.controls.forEach(formControl => {\n      this.fieldsUtils.controlIterator(formControl, this.handleFormArray, this.handleFormGroup, this.handleFormControl);\n    });\n  }\n\n  private readonly handleFormGroup = (formGroup: FormGroup): void => {\n    this.evaluateControl(formGroup);\n    let groupControl = formGroup;\n    if (formGroup.get('value') && formGroup.get('value') instanceof FormGroup) { // Complex Field\n      groupControl = formGroup.get('value') as FormGroup;\n    } else if (formGroup.controls) {\n      // Special Fields like AddressUK, AddressGlobal\n      groupControl = formGroup;\n    }\n    if (groupControl.controls) {\n      Object.keys(groupControl.controls).forEach(cKey => {\n        // EUI-3359.\n        // Get the control from groupControl.controls[cKey] rather than\n        // groupControl.get(cKey) as the latter does pathing and will interpret\n        // full stops in cKey as delimeters for being nested within an array,\n        // which makes no sense in this situation.\n        const control = groupControl.controls[cKey];\n        this.fieldsUtils.controlIterator(control, this.handleFormArray, this.handleFormGroup, this.handleFormControl);\n      });\n    }\n  }\n\n  private evalAllShowHideConditions(): void {\n    this.getCurrentPagesReadOnlyAndFormFieldValues();\n    this.fieldsUtils.controlIterator(this.formGroup, this.handleFormArray, this.handleFormGroup, this.handleFormControl);\n  }\n\n  private buildPath(c: AbstractFormFieldComponent, field: CaseField): string {\n    if (c && c instanceof AbstractFieldWriteComponent) {\n      if (c.idPrefix) {\n        return c.idPrefix + field.id;\n      }\n    }\n    return field.id;\n  }\n\n  private getCurrentPagesReadOnlyAndFormFieldValues(): any {\n    const formFields = this.getFormFieldsValuesIncludingDisabled();\n    this.allFieldValues = this.fieldsUtils.mergeCaseFieldsAndFormFields(this.contextFields, formFields);\n    return this.allFieldValues;\n  }\n\n  private getFormFieldsValuesIncludingDisabled(): any {\n    return this.formGroup.getRawValue();\n  }\n\n  private unsubscribeFromFormChanges(): void {\n    if (this.formChangesSubscription) {\n      this.formChangesSubscription.unsubscribe();\n    }\n  }\n}\n"]}