@hmcts/ccd-case-ui-toolkit 7.0.36-angular-upgrade → 7.0.36-case-consolidated-link

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

@@ -0,0 +1,67 @@
+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';
+import * as i0 from "@angular/core";
+import * as i1 from "rpx-xui-translation";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+import * as i4 from "../palette/base-field/field-write.component";
+import * as i5 from "../../directives/conditional-show/conditional-show-form.directive";
+export class WorkbasketFiltersModule {
+}
+WorkbasketFiltersModule.ɵfac = function WorkbasketFiltersModule_Factory(t) { return new (t || WorkbasketFiltersModule)(); };
+WorkbasketFiltersModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: WorkbasketFiltersModule });
+WorkbasketFiltersModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ providers: [
+        WorkbasketInputFilterService,
+        OrderService,
+        JurisdictionService,
+        AlertService,
+        WindowService,
+    ], imports: [CommonModule,
+        FormsModule,
+        ReactiveFormsModule,
+        PaletteModule,
+        ConditionalShowModule,
+        RpxTranslationModule.forChild()] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(WorkbasketFiltersModule, [{
+        type: NgModule,
+        args: [{
+                imports: [
+                    CommonModule,
+                    FormsModule,
+                    ReactiveFormsModule,
+                    PaletteModule,
+                    ConditionalShowModule,
+                    RpxTranslationModule.forChild()
+                ],
+                declarations: [
+                    WorkbasketFiltersComponent,
+                ],
+                exports: [
+                    WorkbasketFiltersComponent,
+                ],
+                providers: [
+                    WorkbasketInputFilterService,
+                    OrderService,
+                    JurisdictionService,
+                    AlertService,
+                    WindowService,
+                ]
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(WorkbasketFiltersModule, { declarations: [WorkbasketFiltersComponent], imports: [CommonModule,
+        FormsModule,
+        ReactiveFormsModule,
+        PaletteModule,
+        ConditionalShowModule, i1.RpxTranslationModule], exports: [WorkbasketFiltersComponent] }); })();
+i0.ɵɵsetComponentScope(WorkbasketFiltersComponent, function () { return [i2.NgForOf, i2.NgIf, i3.ɵNgNoValidate, i3.NgSelectOption, i3.ɵNgSelectMultipleOption, i3.SelectControlValueAccessor, i3.NgControlStatus, i3.NgControlStatusGroup, i3.NgModel, i3.NgForm, i3.FormGroupDirective, i4.FieldWriteComponent, i5.ConditionalShowFormDirective]; }, function () { return [i1.RpxTranslatePipe]; });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -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.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 = /*@__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/esm2020/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 {
+}
+ConditionalShowModule.ɵfac = function ConditionalShowModule_Factory(t) { return new (t || ConditionalShowModule)(); };
+ConditionalShowModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: ConditionalShowModule });
+ConditionalShowModule.ɵ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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZGl0aW9uYWwtc2hvdy5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jY2QtY2FzZS11aS10b29sa2l0L3NyYy9saWIvc2hhcmVkL2RpcmVjdGl2ZXMvY29uZGl0aW9uYWwtc2hvdy9jb25kaXRpb25hbC1zaG93Lm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQztBQUNqRSxPQUFPLEVBQUUsNEJBQTRCLEVBQUUsTUFBTSxtQ0FBbUMsQ0FBQztBQUNqRixPQUFPLEVBQUUsK0JBQStCLEVBQUUsTUFBTSwrQ0FBK0MsQ0FBQztBQUNoRyxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sNkJBQTZCLENBQUM7O0FBZTdELE1BQU0sT0FBTyxxQkFBcUI7OzBGQUFyQixxQkFBcUI7dUVBQXJCLHFCQUFxQjs0RUFOckI7UUFDVCxXQUFXO1FBQ1gsK0JBQStCO1FBQy9CLGNBQWM7S0FDZjt1RkFFVSxxQkFBcUI7Y0FiakMsUUFBUTtlQUFDO2dCQUNSLFlBQVksRUFBRTtvQkFDWiw0QkFBNEI7aUJBQzdCO2dCQUNELE9BQU8sRUFBRTtvQkFDUCw0QkFBNEI7aUJBQzdCO2dCQUNELFNBQVMsRUFBRTtvQkFDVCxXQUFXO29CQUNYLCtCQUErQjtvQkFDL0IsY0FBYztpQkFDZjthQUNGOzt3RkFDWSxxQkFBcUIsbUJBWDlCLDRCQUE0QixhQUc1Qiw0QkFBNEIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgRmllbGRzVXRpbHMgfSBmcm9tICcuLi8uLi9zZXJ2aWNlcy9maWVsZHMvZmllbGRzLnV0aWxzJztcbmltcG9ydCB7IENvbmRpdGlvbmFsU2hvd0Zvcm1EaXJlY3RpdmUgfSBmcm9tICcuL2NvbmRpdGlvbmFsLXNob3ctZm9ybS5kaXJlY3RpdmUnO1xuaW1wb3J0IHsgQ29uZGl0aW9uYWxTaG93UmVnaXN0cmFyU2VydmljZSB9IGZyb20gJy4vc2VydmljZXMvY29uZGl0aW9uYWwtc2hvdy1yZWdpc3RyYXIuc2VydmljZSc7XG5pbXBvcnQgeyBHcmV5QmFyU2VydmljZSB9IGZyb20gJy4vc2VydmljZXMvZ3JleS1iYXIuc2VydmljZSc7XG5cbkBOZ01vZHVsZSh7XG4gIGRlY2xhcmF0aW9uczogW1xuICAgIENvbmRpdGlvbmFsU2hvd0Zvcm1EaXJlY3RpdmVcbiAgXSxcbiAgZXhwb3J0czogW1xuICAgIENvbmRpdGlvbmFsU2hvd0Zvcm1EaXJlY3RpdmVcbiAgXSxcbiAgcHJvdmlkZXJzOiBbXG4gICAgRmllbGRzVXRpbHMsXG4gICAgQ29uZGl0aW9uYWxTaG93UmVnaXN0cmFyU2VydmljZSxcbiAgICBHcmV5QmFyU2VydmljZVxuICBdXG59KVxuZXhwb3J0IGNsYXNzIENvbmRpdGlvbmFsU2hvd01vZHVsZSB7fVxuIl19

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

@@ -0,0 +1,200 @@
+import { FieldsUtils } from '../../../services/fields/fields.utils';
+import { ConditionParser } from '../services/condition-parser.service';
+export class ShowCondition {
+    // Expects a show condition of the form: <fieldName>="string"
+    constructor(condition) {
+        this.condition = condition;
+        this.conditions = [];
+        if (!!condition) {
+            this.conditions = ConditionParser.parse(condition);
+        }
+    }
+    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;
+    }
+    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);
+    }
+}
+ShowCondition.CONDITION_NOT_EQUALS = '!=';
+ShowCondition.CONDITION_EQUALS = '=';
+ShowCondition.CONTAINS = 'CONTAINS';
+ShowCondition.instanceCache = new Map();
+ShowCondition.validJoinComparators = ['AND', 'OR'];
+ShowCondition.processedList = [];
+//# 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"]}