@hmcts/ccd-case-ui-toolkit 7.0.20 → 7.0.21-CVE-fix

package/esm2022/lib/shared/components/workbasket-filters/workbasket-filters.module.mjs

@@ -0,0 +1,42 @@
+import { __decorate } from "tslib";
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { RpxTranslationModule } from 'rpx-xui-translation';
+import { ConditionalShowModule } from '../../directives/conditional-show/conditional-show.module';
+import { AlertService } from '../../services/alert/alert.service';
+import { JurisdictionService } from '../../services/jurisdiction/jurisdiction.service';
+import { OrderService } from '../../services/order/order.service';
+import { WindowService } from '../../services/window/window.service';
+import { WorkbasketInputFilterService } from '../../services/workbasket/workbasket-input-filter.service';
+import { PaletteModule } from '../palette/palette.module';
+import { WorkbasketFiltersComponent } from './workbasket-filters.component';
+let WorkbasketFiltersModule = class WorkbasketFiltersModule {
+};
+WorkbasketFiltersModule = __decorate([
+    NgModule({
+        imports: [
+            CommonModule,
+            FormsModule,
+            ReactiveFormsModule,
+            PaletteModule,
+            ConditionalShowModule,
+            RpxTranslationModule.forChild()
+        ],
+        declarations: [
+            WorkbasketFiltersComponent,
+        ],
+        exports: [
+            WorkbasketFiltersComponent,
+        ],
+        providers: [
+            WorkbasketInputFilterService,
+            OrderService,
+            JurisdictionService,
+            AlertService,
+            WindowService,
+        ]
+    })
+], WorkbasketFiltersModule);
+export { WorkbasketFiltersModule };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/shared/directives/conditional-show/conditional-show-form.directive.mjs

@@ -0,0 +1,169 @@
+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 {
+    fieldsUtils;
+    caseFields;
+    contextFields = [];
+    formGroup;
+    allFieldValues;
+    formChangesSubscription;
+    constructor(fieldsUtils) {
+        this.fieldsUtils = fieldsUtils;
+    }
+    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.enable({ emitEvent: false });
+                    }
+                }
+            }
+        }
+    }
+    // make sure for the 3 callbacks that we are bound to this via an arrow function
+    handleFormControl = (formControl) => {
+        this.evaluateControl(formControl);
+    };
+    handleFormArray = (formArray) => {
+        this.evaluateControl(formArray);
+        formArray.controls.forEach(formControl => {
+            this.fieldsUtils.controlIterator(formControl, this.handleFormArray, this.handleFormGroup, this.handleFormControl);
+        });
+    };
+    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);
+            });
+        }
+    };
+    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();
+        }
+    }
+    static ɵfac = function ConditionalShowFormDirective_Factory(t) { return new (t || ConditionalShowFormDirective)(i0.ɵɵdirectiveInject(i1.FieldsUtils)); };
+    static ɵdir = /*@__PURE__*/ 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) {\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"]}

package/esm2022/lib/shared/directives/conditional-show/conditional-show.module.mjs

@@ -0,0 +1,33 @@
+import { NgModule } from '@angular/core';
+import { FieldsUtils } from '../../services/fields/fields.utils';
+import { ConditionalShowFormDirective } from './conditional-show-form.directive';
+import { ConditionalShowRegistrarService } from './services/conditional-show-registrar.service';
+import { GreyBarService } from './services/grey-bar.service';
+import * as i0 from "@angular/core";
+export class ConditionalShowModule {
+    static ɵfac = function ConditionalShowModule_Factory(t) { return new (t || ConditionalShowModule)(); };
+    static ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: ConditionalShowModule });
+    static ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ providers: [
+            FieldsUtils,
+            ConditionalShowRegistrarService,
+            GreyBarService
+        ] });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ConditionalShowModule, [{
+        type: NgModule,
+        args: [{
+                declarations: [
+                    ConditionalShowFormDirective
+                ],
+                exports: [
+                    ConditionalShowFormDirective
+                ],
+                providers: [
+                    FieldsUtils,
+                    ConditionalShowRegistrarService,
+                    GreyBarService
+                ]
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(ConditionalShowModule, { declarations: [ConditionalShowFormDirective], exports: [ConditionalShowFormDirective] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZGl0aW9uYWwtc2hvdy5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jY2QtY2FzZS11aS10b29sa2l0L3NyYy9saWIvc2hhcmVkL2RpcmVjdGl2ZXMvY29uZGl0aW9uYWwtc2hvdy9jb25kaXRpb25hbC1zaG93Lm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQztBQUNqRSxPQUFPLEVBQUUsNEJBQTRCLEVBQUUsTUFBTSxtQ0FBbUMsQ0FBQztBQUNqRixPQUFPLEVBQUUsK0JBQStCLEVBQUUsTUFBTSwrQ0FBK0MsQ0FBQztBQUNoRyxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sNkJBQTZCLENBQUM7O0FBZTdELE1BQU0sT0FBTyxxQkFBcUI7K0VBQXJCLHFCQUFxQjs0REFBckIscUJBQXFCO2lFQU5yQjtZQUNULFdBQVc7WUFDWCwrQkFBK0I7WUFDL0IsY0FBYztTQUNmOzt1RkFFVSxxQkFBcUI7Y0FiakMsUUFBUTtlQUFDO2dCQUNSLFlBQVksRUFBRTtvQkFDWiw0QkFBNEI7aUJBQzdCO2dCQUNELE9BQU8sRUFBRTtvQkFDUCw0QkFBNEI7aUJBQzdCO2dCQUNELFNBQVMsRUFBRTtvQkFDVCxXQUFXO29CQUNYLCtCQUErQjtvQkFDL0IsY0FBYztpQkFDZjthQUNGOzt3RkFDWSxxQkFBcUIsbUJBWDlCLDRCQUE0QixhQUc1Qiw0QkFBNEIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgRmllbGRzVXRpbHMgfSBmcm9tICcuLi8uLi9zZXJ2aWNlcy9maWVsZHMvZmllbGRzLnV0aWxzJztcbmltcG9ydCB7IENvbmRpdGlvbmFsU2hvd0Zvcm1EaXJlY3RpdmUgfSBmcm9tICcuL2NvbmRpdGlvbmFsLXNob3ctZm9ybS5kaXJlY3RpdmUnO1xuaW1wb3J0IHsgQ29uZGl0aW9uYWxTaG93UmVnaXN0cmFyU2VydmljZSB9IGZyb20gJy4vc2VydmljZXMvY29uZGl0aW9uYWwtc2hvdy1yZWdpc3RyYXIuc2VydmljZSc7XG5pbXBvcnQgeyBHcmV5QmFyU2VydmljZSB9IGZyb20gJy4vc2VydmljZXMvZ3JleS1iYXIuc2VydmljZSc7XG5cbkBOZ01vZHVsZSh7XG4gIGRlY2xhcmF0aW9uczogW1xuICAgIENvbmRpdGlvbmFsU2hvd0Zvcm1EaXJlY3RpdmVcbiAgXSxcbiAgZXhwb3J0czogW1xuICAgIENvbmRpdGlvbmFsU2hvd0Zvcm1EaXJlY3RpdmVcbiAgXSxcbiAgcHJvdmlkZXJzOiBbXG4gICAgRmllbGRzVXRpbHMsXG4gICAgQ29uZGl0aW9uYWxTaG93UmVnaXN0cmFyU2VydmljZSxcbiAgICBHcmV5QmFyU2VydmljZVxuICBdXG59KVxuZXhwb3J0IGNsYXNzIENvbmRpdGlvbmFsU2hvd01vZHVsZSB7fVxuIl19

package/esm2022/lib/shared/directives/conditional-show/domain/conditional-show.model.mjs

@@ -0,0 +1,201 @@
+import { FieldsUtils } from '../../../services/fields/fields.utils';
+import { ConditionParser } from '../services/condition-parser.service';
+export class ShowCondition {
+    condition;
+    static CONDITION_NOT_EQUALS = '!=';
+    static CONDITION_EQUALS = '=';
+    static CONTAINS = 'CONTAINS';
+    static instanceCache = new Map();
+    static validJoinComparators = ['AND', 'OR'];
+    static processedList = [];
+    conditions = [];
+    static addPathPrefixToCondition(showCondition, pathPrefix) {
+        if (!pathPrefix || pathPrefix === '') {
+            return showCondition;
+        }
+        if (!showCondition) {
+            return '';
+        }
+        const formula = ConditionParser.parse(showCondition);
+        if (!formula) {
+            return showCondition;
+        }
+        this.processedList = [];
+        showCondition = showCondition.replace(/CONTAINS/g, ' CONTAINS');
+        const processedCondition = this.processAddPathPrefixToCondition(formula, pathPrefix, showCondition);
+        return processedCondition.replace(/ CONTAINS/g, 'CONTAINS');
+    }
+    static processAddPathPrefixToCondition(formula, pathPrefix, originalCondition) {
+        let finalCondition = originalCondition;
+        if (Array.isArray(formula)) {
+            formula.forEach(condition => {
+                if (typeof condition === 'string' && this.validJoinComparators.indexOf(condition) !== -1) {
+                    // do nothing
+                }
+                else {
+                    if (Array.isArray(condition)) {
+                        finalCondition = this.processAddPathPrefixToCondition(condition, pathPrefix, finalCondition);
+                    }
+                    else {
+                        finalCondition = this.extractConditions(condition, pathPrefix, finalCondition);
+                    }
+                }
+            });
+        }
+        else {
+            finalCondition = this.extractConditions(formula, pathPrefix, finalCondition);
+        }
+        return finalCondition;
+    }
+    static extractConditions(condition, pathPrefix, originalCondition) {
+        if (condition.fieldReference.startsWith(pathPrefix)) {
+            return originalCondition;
+        }
+        else {
+            if (originalCondition.indexOf(condition.fieldReference) > -1) {
+                if (this.processedList && this.processedList.indexOf(condition.fieldReference) === -1) {
+                    this.processedList.push(condition.fieldReference);
+                    const regularExp = new RegExp(`(\\b)${condition.fieldReference}(?=[^"]*(?:"[^"]*"[^"]*)*$)(\\b)`, 'g');
+                    return originalCondition.replace(regularExp, `${pathPrefix}.${condition.fieldReference}`);
+                }
+                else {
+                    return originalCondition;
+                }
+            }
+        }
+    }
+    // Cache instances so that we can cache results more effectively
+    static getInstance(condition) {
+        let instance = this.instanceCache.get(condition);
+        if (!instance) {
+            instance = new ShowCondition(condition);
+            this.instanceCache.set(condition, instance);
+        }
+        return instance;
+    }
+    static getField(condition) {
+        let separator = ShowCondition.CONTAINS;
+        if (condition.indexOf(ShowCondition.CONTAINS) < 0) {
+            separator = ShowCondition.CONDITION_EQUALS;
+            if (condition.indexOf(ShowCondition.CONDITION_NOT_EQUALS) > -1) {
+                separator = ShowCondition.CONDITION_NOT_EQUALS;
+            }
+        }
+        return [condition.split(separator)[0], separator];
+    }
+    static getConditions(formula) {
+        const conditionList = [];
+        if (!!formula) {
+            const newFormula = typeof formula === 'string' ? JSON.parse(formula) : formula;
+            if (Array.isArray(newFormula)) {
+                newFormula.forEach(condition => {
+                    if (!(typeof condition === 'string' && this.validJoinComparators.indexOf(condition) !== -1)) {
+                        if (Array.isArray(condition)) {
+                            conditionList.push(ShowCondition.getConditions(condition).toString());
+                        }
+                        else {
+                            conditionList.push(condition.fieldReference + condition.comparator + condition.value);
+                        }
+                    }
+                });
+            }
+            else {
+                conditionList.push(newFormula.fieldReference + newFormula.comparator + newFormula.value);
+            }
+        }
+        return conditionList.toString();
+    }
+    /**
+     * Determine whether a ShowCondition model is affected by fields that have
+     * a display_context of HIDDEN or READONLY, which means they aren't able to
+     * be changed by the user's actions.
+     *
+     * @param showCondition The ShowCondition model to evaluate.
+     * @param caseFields Inspected to see appropriate display_contexts.
+     */
+    static hiddenCannotChange(showCondition, caseFields) {
+        if (showCondition && showCondition.conditions.length && caseFields) {
+            const conditions = this.getConditions(showCondition.conditions).split(',');
+            if (conditions && conditions.length > 0) {
+                let allUnchangeable = true;
+                for (const condition of conditions) {
+                    const [field] = ShowCondition.getField(condition);
+                    const path = field.split('.');
+                    let head = path.shift();
+                    let caseField = caseFields.find(cf => cf.id === head);
+                    while (path.length > 0) {
+                        head = path.shift();
+                        if (caseField) {
+                            // Jump out if this is HIDDEN or READONLY, regardless of whether or not it's
+                            // complex or a collection - nested fields will "inherit" the display_context.
+                            if (['HIDDEN', 'READONLY'].indexOf(caseField.display_context) > -1) {
+                                break;
+                            }
+                            // Consider what type of field this is.
+                            const ft = caseField.field_type;
+                            // tslint:disable-next-line:switch-default
+                            switch (ft.type) {
+                                case 'Collection':
+                                    if (ft.collection_field_type.type === 'Complex' && ft.collection_field_type.complex_fields) {
+                                        caseField = ft.collection_field_type.complex_fields.find(cf => cf.id === head);
+                                    }
+                                    break;
+                                case 'Complex':
+                                    if (ft.complex_fields) {
+                                        caseField = ft.complex_fields.find(cf => cf.id === head);
+                                    }
+                                    break;
+                            }
+                        }
+                    }
+                    if (caseField) {
+                        allUnchangeable = allUnchangeable && ['HIDDEN', 'READONLY'].indexOf(caseField.display_context) > -1;
+                    }
+                }
+                return allUnchangeable;
+            }
+        }
+        return false;
+    }
+    // Expects a show condition of the form: <fieldName>="string"
+    constructor(condition) {
+        this.condition = condition;
+        if (!!condition) {
+            this.conditions = ConditionParser.parse(condition);
+        }
+    }
+    match(fields, path) {
+        return ConditionParser.evaluate(fields, this.conditions, this.updatePathName(path));
+    }
+    updatePathName(path) {
+        if (path && path.split(/[_]+/g).length > 0) {
+            /* tslint:disable-next-line */
+            let [pathName, ...pathTail] = path.split(/[_]+/g);
+            const pathFinalIndex = pathTail.pop();
+            const pathTailString = pathTail.toString();
+            pathTail = pathTail.map((value) => {
+                return Number(pathFinalIndex) === Number(value) ? pathName : value;
+            });
+            return pathTailString !== pathTail.toString()
+                ? `${pathName}_${pathTail.join('_')}_${pathFinalIndex}`
+                : path;
+        }
+        else {
+            return path;
+        }
+    }
+    matchByContextFields(contextFields) {
+        return this.match(FieldsUtils.toValuesMap(contextFields));
+    }
+    /**
+     * Determine whether this is affected by fields that have a display_context
+     * of HIDDEN or READONLY, which means they aren't able to be changed by the
+     * user's actions.
+     *
+     * @param caseFields Inspected to see appropriate display_contexts.
+     */
+    hiddenCannotChange(caseFields) {
+        return ShowCondition.hiddenCannotChange(this, caseFields);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"conditional-show.model.js","sourceRoot":"","sources":["../../../../../../../../projects/ccd-case-ui-toolkit/src/lib/shared/directives/conditional-show/domain/conditional-show.model.ts"],"names":[],"mappings":"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","sourcesContent":["import  * as _score from 'underscore';\nimport { CaseField } from '../../../domain/definition/case-field.model';\nimport { FieldsUtils } from '../../../services/fields/fields.utils';\nimport { ConditionParser } from '../services/condition-parser.service';\n\nexport class ShowCondition {\n  public static readonly CONDITION_NOT_EQUALS = '!=';\n  public static readonly CONDITION_EQUALS = '=';\n  public static readonly CONTAINS = 'CONTAINS';\n  private static instanceCache = new Map<string, ShowCondition>();\n  private static readonly validJoinComparators = ['AND', 'OR'];\n  private static processedList: string[] = [];\n  private conditions = [];\n\n  public static addPathPrefixToCondition(showCondition: string, pathPrefix: string): string {\n    if (!pathPrefix || pathPrefix === '') {\n      return showCondition;\n    }\n    if (!showCondition) {\n      return '';\n    }\n\n    const formula = ConditionParser.parse(showCondition);\n    if (!formula) {\n      return showCondition;\n    }\n    this.processedList = [];\n    showCondition = showCondition.replace(/CONTAINS/g, ' CONTAINS');\n    const processedCondition = this.processAddPathPrefixToCondition(formula, pathPrefix, showCondition);\n    return processedCondition.replace(/ CONTAINS/g, 'CONTAINS');\n  }\n\n  private static processAddPathPrefixToCondition(formula: any, pathPrefix: string, originalCondition: string): string {\n    let finalCondition: string = originalCondition;\n    if (Array.isArray(formula)) {\n      formula.forEach(condition => {\n        if (typeof condition === 'string' && this.validJoinComparators.indexOf(condition) !== -1) {\n          // do nothing\n        } else {\n          if (Array.isArray(condition)) {\n            finalCondition = this.processAddPathPrefixToCondition(condition, pathPrefix, finalCondition);\n          } else {\n            finalCondition = this.extractConditions(condition, pathPrefix, finalCondition);\n          }\n        }\n      });\n    } else {\n      finalCondition = this.extractConditions(formula, pathPrefix, finalCondition);\n    }\n    return finalCondition;\n  }\n\n  private static extractConditions(condition: any, pathPrefix: string, originalCondition: string): string {\n    if (condition.fieldReference.startsWith(pathPrefix)) {\n      return originalCondition;\n    } else {\n      if (originalCondition.indexOf(condition.fieldReference) > -1) {\n        if (this.processedList && this.processedList.indexOf(condition.fieldReference) === -1) {\n          this.processedList.push(condition.fieldReference);\n          const regularExp = new RegExp(`(\\\\b)${condition.fieldReference}(?=[^\"]*(?:\"[^\"]*\"[^\"]*)*$)(\\\\b)`, 'g');\n          return originalCondition.replace(regularExp, `${pathPrefix}.${condition.fieldReference}`);\n        } else {\n          return originalCondition;\n        }\n      }\n    }\n  }\n\n  // Cache instances so that we can cache results more effectively\n  public static getInstance(condition: string): ShowCondition {\n    let instance = this.instanceCache.get(condition);\n    if (!instance) {\n      instance = new ShowCondition(condition);\n      this.instanceCache.set(condition, instance);\n    }\n    return instance;\n  }\n\n  private static getField(condition: string): [string, string?] {\n    let separator: string = ShowCondition.CONTAINS;\n    if (condition.indexOf(ShowCondition.CONTAINS) < 0) {\n      separator = ShowCondition.CONDITION_EQUALS;\n      if (condition.indexOf(ShowCondition.CONDITION_NOT_EQUALS) > -1) {\n        separator = ShowCondition.CONDITION_NOT_EQUALS;\n      }\n    }\n    return [ condition.split(separator)[0], separator ];\n  }\n\n  private static getConditions(formula: any): string {\n    const conditionList: string[] = [];\n    if (!!formula) {\n      const newFormula = typeof formula === 'string' ? JSON.parse(formula) : formula;\n      if (Array.isArray(newFormula)) {\n        newFormula.forEach(condition => {\n          if (!(typeof condition === 'string' && this.validJoinComparators.indexOf(condition) !== -1)) {\n            if (Array.isArray(condition)) {\n              conditionList.push(ShowCondition.getConditions(condition).toString());\n            } else {\n              conditionList.push(condition.fieldReference + condition.comparator + condition.value);\n            }\n          }\n        });\n      } else {\n        conditionList.push(newFormula.fieldReference + newFormula.comparator + newFormula.value);\n      }\n    }\n    return conditionList.toString();\n  }\n\n  /**\n   * Determine whether a ShowCondition model is affected by fields that have\n   * a display_context of HIDDEN or READONLY, which means they aren't able to\n   * be changed by the user's actions.\n   *\n   * @param showCondition The ShowCondition model to evaluate.\n   * @param caseFields Inspected to see appropriate display_contexts.\n   */\n  public static hiddenCannotChange(showCondition: ShowCondition, caseFields: CaseField[]): boolean {\n    if (showCondition && showCondition.conditions.length && caseFields) {\n      const conditions: string[] = this.getConditions(showCondition.conditions).split(',');\n      if (conditions && conditions.length > 0) {\n        let allUnchangeable = true;\n        for (const condition of conditions) {\n          const [field] = ShowCondition.getField(condition);\n          const path: string[] = field.split('.');\n          let head = path.shift();\n          let caseField: CaseField = caseFields.find(cf => cf.id === head);\n          while (path.length > 0) {\n            head = path.shift();\n            if (caseField) {\n              // Jump out if this is HIDDEN or READONLY, regardless of whether or not it's\n              // complex or a collection - nested fields will \"inherit\" the display_context.\n              if (['HIDDEN', 'READONLY'].indexOf(caseField.display_context) > -1) {\n                break;\n              }\n\n              // Consider what type of field this is.\n              const ft = caseField.field_type;\n              // tslint:disable-next-line:switch-default\n              switch (ft.type) {\n                case 'Collection':\n                  if (ft.collection_field_type.type === 'Complex' && ft.collection_field_type.complex_fields) {\n                    caseField = ft.collection_field_type.complex_fields.find(cf => cf.id === head);\n                  }\n                  break;\n                case 'Complex':\n                  if (ft.complex_fields) {\n                    caseField = ft.complex_fields.find(cf => cf.id === head);\n                  }\n                  break;\n              }\n            }\n          }\n          if (caseField) {\n            allUnchangeable = allUnchangeable && ['HIDDEN', 'READONLY'].indexOf(caseField.display_context) > -1;\n          }\n        }\n        return allUnchangeable;\n      }\n    }\n    return false;\n  }\n\n  // Expects a show condition of the form: <fieldName>=\"string\"\n  constructor(public condition: string) {\n    if (!!condition) {\n      this.conditions = ConditionParser.parse(condition);\n    }\n  }\n\n  public match(fields: object, path?: string): boolean {\n    return ConditionParser.evaluate(fields, this.conditions, this.updatePathName(path));\n  }\n\n  private updatePathName(path: string): string {\n    if (path && path.split(/[_]+/g).length > 0) {\n       /* tslint:disable-next-line */\n      let [pathName, ...pathTail] = path.split(/[_]+/g);\n      const pathFinalIndex = pathTail.pop();\n      const pathTailString = pathTail.toString();\n\n      pathTail = pathTail.map((value) => {\n        return Number(pathFinalIndex) === Number(value) ? pathName : value;\n      });\n\n      return pathTailString !== pathTail.toString()\n        ? `${pathName}_${pathTail.join('_')}_${pathFinalIndex}`\n        : path;\n    } else {\n      return path;\n    }\n  }\n\n  public matchByContextFields(contextFields: CaseField[]): boolean {\n    return this.match(FieldsUtils.toValuesMap(contextFields));\n  }\n\n  /**\n   * Determine whether this is affected by fields that have a display_context\n   * of HIDDEN or READONLY, which means they aren't able to be changed by the\n   * user's actions.\n   *\n   * @param caseFields Inspected to see appropriate display_contexts.\n   */\n  public hiddenCannotChange(caseFields: CaseField[]): boolean {\n    return ShowCondition.hiddenCannotChange(this, caseFields);\n  }\n}\n"]}

package/esm2022/lib/shared/directives/conditional-show/services/conditional-show-registrar.service.mjs

@@ -0,0 +1,17 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ConditionalShowRegistrarService {
+    registeredDirectives = [];
+    register(newDirective) {
+        this.registeredDirectives.push(newDirective);
+    }
+    reset() {
+        this.registeredDirectives = [];
+    }
+    static ɵfac = function ConditionalShowRegistrarService_Factory(t) { return new (t || ConditionalShowRegistrarService)(); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ConditionalShowRegistrarService, factory: ConditionalShowRegistrarService.ɵfac });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ConditionalShowRegistrarService, [{
+        type: Injectable
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZGl0aW9uYWwtc2hvdy1yZWdpc3RyYXIuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NjZC1jYXNlLXVpLXRvb2xraXQvc3JjL2xpYi9zaGFyZWQvZGlyZWN0aXZlcy9jb25kaXRpb25hbC1zaG93L3NlcnZpY2VzL2NvbmRpdGlvbmFsLXNob3ctcmVnaXN0cmFyLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFJM0MsTUFBTSxPQUFPLCtCQUErQjtJQUNuQyxvQkFBb0IsR0FBbUMsRUFBRSxDQUFDO0lBRTFELFFBQVEsQ0FBQyxZQUEwQztRQUN0RCxJQUFJLENBQUMsb0JBQW9CLENBQUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxDQUFDO0lBQ2pELENBQUM7SUFFTSxLQUFLO1FBQ1YsSUFBSSxDQUFDLG9CQUFvQixHQUFHLEVBQUUsQ0FBQztJQUNqQyxDQUFDO3lGQVRVLCtCQUErQjtnRUFBL0IsK0JBQStCLFdBQS9CLCtCQUErQjs7dUZBQS9CLCtCQUErQjtjQUQzQyxVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQ29uZGl0aW9uYWxTaG93Rm9ybURpcmVjdGl2ZSB9IGZyb20gJy4uL2NvbmRpdGlvbmFsLXNob3ctZm9ybS5kaXJlY3RpdmUnO1xuXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgQ29uZGl0aW9uYWxTaG93UmVnaXN0cmFyU2VydmljZSB7XG4gIHB1YmxpYyByZWdpc3RlcmVkRGlyZWN0aXZlczogQ29uZGl0aW9uYWxTaG93Rm9ybURpcmVjdGl2ZVtdID0gW107XG5cbiAgcHVibGljIHJlZ2lzdGVyKG5ld0RpcmVjdGl2ZTogQ29uZGl0aW9uYWxTaG93Rm9ybURpcmVjdGl2ZSk6IHZvaWQge1xuICAgICAgdGhpcy5yZWdpc3RlcmVkRGlyZWN0aXZlcy5wdXNoKG5ld0RpcmVjdGl2ZSk7XG4gIH1cblxuICBwdWJsaWMgcmVzZXQoKTogdm9pZCB7XG4gICAgdGhpcy5yZWdpc3RlcmVkRGlyZWN0aXZlcyA9IFtdO1xuICB9XG59XG4iXX0=

package/esm2022/lib/shared/directives/conditional-show/services/grey-bar.service.mjs

@@ -0,0 +1,48 @@
+import { Injectable, RendererFactory2 } from '@angular/core';
+import * as i0 from "@angular/core";
+/** Keeps track of initially hidden fields that toggle to show on the page (parent page).
+ *  Used to decide whether to redisplay the grey bar when returning to the page during
+ *  navigation between pages.
+ */
+export class GreyBarService {
+    fieldsToggledToShow = [];
+    renderer;
+    constructor(rendererFactory) {
+        this.renderer = rendererFactory.createRenderer(null, null);
+    }
+    showGreyBar(field, el) {
+        if (!field.isCollection()) {
+            this.addGreyBar(el);
+        }
+    }
+    removeGreyBar(el) {
+        const divSelector = el.nativeElement.querySelector('div');
+        if (divSelector) {
+            this.renderer.removeClass(divSelector, 'show-condition-grey-bar');
+        }
+    }
+    addToggledToShow(fieldId) {
+        this.fieldsToggledToShow.push(fieldId);
+    }
+    removeToggledToShow(fieldId) {
+        this.fieldsToggledToShow = this.fieldsToggledToShow.filter(id => id !== fieldId);
+    }
+    wasToggledToShow(fieldId) {
+        return this.fieldsToggledToShow.find(id => id === fieldId) !== undefined;
+    }
+    reset() {
+        this.fieldsToggledToShow = [];
+    }
+    addGreyBar(el) {
+        const divSelector = el.nativeElement.querySelector('div');
+        if (divSelector) {
+            this.renderer.addClass(divSelector, 'show-condition-grey-bar');
+        }
+    }
+    static ɵfac = function GreyBarService_Factory(t) { return new (t || GreyBarService)(i0.ɵɵinject(i0.RendererFactory2)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: GreyBarService, factory: GreyBarService.ɵfac });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(GreyBarService, [{
+        type: Injectable
+    }], function () { return [{ type: i0.RendererFactory2 }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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