@hmcts/ccd-case-ui-toolkit 7.0.33 → 7.0.35-angular-upgrade

package/esm2022/lib/shared/services/form/field-type-sanitiser.mjs

@@ -0,0 +1,91 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class FieldTypeSanitiser {
+    static FIELD_TYPE_COMPLEX = 'Complex';
+    static FIELD_TYPE_COLLECTION = 'Collection';
+    static FIELD_TYPE_DYNAMIC_LIST = 'DynamicList';
+    static FIELD_TYPE_DYNAMIC_RADIO_LIST = 'DynamicRadioList';
+    static FIELD_TYPE_DYNAMIC_MULTISELECT_LIST = 'DynamicMultiSelectList';
+    /**
+     * This method finds dynamiclists in a form and replaces their string
+     * values, with a JSON object, as below:
+     * From: 'xyz'
+     * To  : {
+     *   value: { code:'xyz', label:'XYZ' },
+     *   list_items: [
+     *     { code:'xyz', label:'XYZ'},
+     *     { code:'abc', label:'ABC'}
+     *   ]
+     * }
+     * @param caseFields The CaseFields to assess.
+     * @param data The data in the form.
+     */
+    sanitiseLists(caseFields, data) {
+        if (!data || !caseFields) {
+            return;
+        }
+        caseFields.forEach(caseField => {
+            // tslint:disable-next-line:switch-default
+            switch (caseField.field_type.type) {
+                case FieldTypeSanitiser.FIELD_TYPE_DYNAMIC_MULTISELECT_LIST:
+                    this.convertArrayToDynamicListOutput(caseField, data);
+                    break;
+                case FieldTypeSanitiser.FIELD_TYPE_DYNAMIC_RADIO_LIST:
+                case FieldTypeSanitiser.FIELD_TYPE_DYNAMIC_LIST:
+                    this.convertStringToDynamicListOutput(caseField, data);
+                    break;
+                case FieldTypeSanitiser.FIELD_TYPE_COMPLEX:
+                    this.sanitiseLists(caseField.field_type.complex_fields, data[caseField.id]);
+                    break;
+                case FieldTypeSanitiser.FIELD_TYPE_COLLECTION:
+                    if (Array.isArray(data[caseField.id])) {
+                        data[caseField.id].forEach((formElement) => {
+                            this.sanitiseLists(caseField.field_type.collection_field_type.complex_fields, formElement.value);
+                        });
+                    }
+                    break;
+            }
+        });
+    }
+    convertArrayToDynamicListOutput(field, data) {
+        const values = data[field.id];
+        if (Array.isArray(values)) {
+            const listItems = this.getListItems(field);
+            const matches = listItems.filter(item => values.map(v => v.code).indexOf(item.code) !== -1);
+            data[field.id] = {
+                value: matches,
+                list_items: listItems
+            };
+        }
+    }
+    convertStringToDynamicListOutput(field, data) {
+        const stringValue = data[field.id];
+        if (typeof stringValue === 'string') {
+            const listItems = this.getListItems(field);
+            const matches = listItems.filter(value => value.code === stringValue);
+            if (matches && matches.length > 0) {
+                data[field.id] = {
+                    value: matches[0],
+                    list_items: listItems
+                };
+            }
+        }
+    }
+    getListItems(field) {
+        if (field) {
+            if (field.list_items) {
+                return field.list_items;
+            }
+            if (field.formatted_value && field.formatted_value.list_items) {
+                return field.formatted_value.list_items;
+            }
+        }
+        return [];
+    }
+    static ɵfac = function FieldTypeSanitiser_Factory(t) { return new (t || FieldTypeSanitiser)(); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: FieldTypeSanitiser, factory: FieldTypeSanitiser.ɵfac });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FieldTypeSanitiser, [{
+        type: Injectable
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"field-type-sanitiser.js","sourceRoot":"","sources":["../../../../../../../projects/ccd-case-ui-toolkit/src/lib/shared/services/form/field-type-sanitiser.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { CaseField } from '../../domain/definition/case-field.model';\nimport { FieldTypeEnum } from '../../domain/definition/field-type-enum.model';\n\n@Injectable()\nexport class FieldTypeSanitiser {\n  public static readonly FIELD_TYPE_COMPLEX: FieldTypeEnum = 'Complex';\n  public static readonly FIELD_TYPE_COLLECTION: FieldTypeEnum = 'Collection';\n  public static readonly FIELD_TYPE_DYNAMIC_LIST: FieldTypeEnum = 'DynamicList';\n  public static readonly FIELD_TYPE_DYNAMIC_RADIO_LIST: FieldTypeEnum = 'DynamicRadioList';\n  public static readonly FIELD_TYPE_DYNAMIC_MULTISELECT_LIST: FieldTypeEnum = 'DynamicMultiSelectList';\n  /**\n   * This method finds dynamiclists in a form and replaces their string\n   * values, with a JSON object, as below:\n   * From: 'xyz'\n   * To  : {\n   *   value: { code:'xyz', label:'XYZ' },\n   *   list_items: [\n   *     { code:'xyz', label:'XYZ'},\n   *     { code:'abc', label:'ABC'}\n   *   ]\n   * }\n   * @param caseFields The CaseFields to assess.\n   * @param data The data in the form.\n   */\n   public sanitiseLists(caseFields: CaseField[], data: any) {\n    if (!data || !caseFields) {\n      return;\n    }\n    caseFields.forEach(caseField => {\n      // tslint:disable-next-line:switch-default\n      switch (caseField.field_type.type) {\n        case FieldTypeSanitiser.FIELD_TYPE_DYNAMIC_MULTISELECT_LIST:\n          this.convertArrayToDynamicListOutput(caseField, data);\n          break;\n        case FieldTypeSanitiser.FIELD_TYPE_DYNAMIC_RADIO_LIST:\n        case FieldTypeSanitiser.FIELD_TYPE_DYNAMIC_LIST:\n          this.convertStringToDynamicListOutput(caseField, data);\n          break;\n\n        case FieldTypeSanitiser.FIELD_TYPE_COMPLEX:\n          this.sanitiseLists(caseField.field_type.complex_fields, data[caseField.id]);\n          break;\n\n        case FieldTypeSanitiser.FIELD_TYPE_COLLECTION:\n          if (Array.isArray(data[caseField.id])) {\n            data[caseField.id].forEach((formElement: any) => {\n              this.sanitiseLists(caseField.field_type.collection_field_type.complex_fields, formElement.value);\n            });\n          }\n          break;\n      }\n\n    });\n  }\n\n  private convertArrayToDynamicListOutput(field: CaseField, data: any): void {\n    const values = data[field.id];\n\n    if (Array.isArray(values)) {\n      const listItems = this.getListItems(field);\n      const matches = listItems.filter(item => values.map(v => v.code).indexOf(item.code) !== -1);\n\n      data[field.id] = {\n        value: matches,\n        list_items: listItems\n      };\n    }\n  }\n\n  private convertStringToDynamicListOutput(field: CaseField, data: any): void {\n    const stringValue = data[field.id];\n    if (typeof stringValue === 'string') {\n      const listItems = this.getListItems(field);\n      const matches = listItems.filter(value => value.code === stringValue);\n      if (matches && matches.length > 0) {\n        data[field.id] = {\n          value: matches[0],\n          list_items: listItems\n        };\n      }\n    }\n  }\n\n  private getListItems(field: CaseField): any[] {\n    if (field) {\n      if (field.list_items) {\n        return field.list_items;\n      }\n      if (field.formatted_value && field.formatted_value.list_items) {\n        return field.formatted_value.list_items;\n      }\n    }\n    return [];\n  }\n}\n"]}

package/esm2022/lib/shared/services/form/form-error.service.mjs

@@ -0,0 +1,46 @@
+import { Injectable } from '@angular/core';
+import { FormArray } from '@angular/forms';
+import * as i0 from "@angular/core";
+export class FormErrorService {
+    mapFieldErrors(errors, form, errorKey) {
+        errors.forEach(error => {
+            const formControl = this.getFormControl(form, error.id);
+            if (formControl) {
+                formControl.setErrors({
+                    [errorKey]: error.message
+                });
+            }
+        });
+    }
+    getFormControl(form, fieldId) {
+        const fields = fieldId.split('.');
+        let group = form;
+        let inArray = false;
+        let control;
+        fields.every((field, index) => {
+            if (index === fields.length - 1) {
+                control = group.controls[field];
+            }
+            else {
+                group = group.controls[field];
+                if (inArray && group.controls['value']) {
+                    group = group.controls['value'];
+                }
+                if (group && group.constructor && FormArray.name === group.constructor.name) {
+                    inArray = true;
+                }
+                else {
+                    inArray = false;
+                }
+            }
+            return !!group;
+        });
+        return control;
+    }
+    static ɵfac = function FormErrorService_Factory(t) { return new (t || FormErrorService)(); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: FormErrorService, factory: FormErrorService.ɵfac });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FormErrorService, [{
+        type: Injectable
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybS1lcnJvci5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2NkLWNhc2UtdWktdG9vbGtpdC9zcmMvbGliL3NoYXJlZC9zZXJ2aWNlcy9mb3JtL2Zvcm0tZXJyb3Iuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBRSxTQUFTLEVBQTBCLE1BQU0sZ0JBQWdCLENBQUM7O0FBR25FLE1BQU0sT0FBTyxnQkFBZ0I7SUFFcEIsY0FBYyxDQUFDLE1BQXlDLEVBQUUsSUFBZSxFQUFFLFFBQWdCO1FBRWhHLE1BQU0sQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLEVBQUU7WUFDckIsTUFBTSxXQUFXLEdBQUcsSUFBSSxDQUFDLGNBQWMsQ0FBQyxJQUFJLEVBQUUsS0FBSyxDQUFDLEVBQUUsQ0FBQyxDQUFDO1lBRXhELElBQUksV0FBVyxFQUFFLENBQUM7Z0JBQ2hCLFdBQVcsQ0FBQyxTQUFTLENBQUM7b0JBQ3BCLENBQUMsUUFBUSxDQUFDLEVBQUUsS0FBSyxDQUFDLE9BQU87aUJBQzFCLENBQUMsQ0FBQztZQUNMLENBQUM7UUFDSCxDQUFDLENBQUMsQ0FBQztJQUNMLENBQUM7SUFFTyxjQUFjLENBQUMsSUFBZSxFQUFFLE9BQWU7UUFDckQsTUFBTSxNQUFNLEdBQUcsT0FBTyxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUVsQyxJQUFJLEtBQUssR0FBYyxJQUFJLENBQUM7UUFDNUIsSUFBSSxPQUFPLEdBQUcsS0FBSyxDQUFDO1FBQ3BCLElBQUksT0FBb0IsQ0FBQztRQUN6QixNQUFNLENBQUMsS0FBSyxDQUFDLENBQUMsS0FBSyxFQUFFLEtBQUssRUFBRSxFQUFFO1lBQzVCLElBQUksS0FBSyxLQUFLLE1BQU0sQ0FBQyxNQUFNLEdBQUcsQ0FBQyxFQUFFLENBQUM7Z0JBQ2hDLE9BQU8sR0FBRyxLQUFLLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBZ0IsQ0FBQztZQUNqRCxDQUFDO2lCQUFNLENBQUM7Z0JBQ04sS0FBSyxHQUFHLEtBQUssQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFjLENBQUM7Z0JBRTNDLElBQUksT0FBTyxJQUFJLEtBQUssQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFDLEVBQUUsQ0FBQztvQkFDdkMsS0FBSyxHQUFHLEtBQUssQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFjLENBQUM7Z0JBQy9DLENBQUM7Z0JBRUQsSUFBSSxLQUFLLElBQUksS0FBSyxDQUFDLFdBQVcsSUFBSSxTQUFTLENBQUMsSUFBSSxLQUFLLEtBQUssQ0FBQyxXQUFXLENBQUMsSUFBSSxFQUFFLENBQUM7b0JBQzVFLE9BQU8sR0FBRyxJQUFJLENBQUM7Z0JBQ2pCLENBQUM7cUJBQU0sQ0FBQztvQkFDTixPQUFPLEdBQUcsS0FBSyxDQUFDO2dCQUNsQixDQUFDO1lBQ0gsQ0FBQztZQUNELE9BQU8sQ0FBQyxDQUFDLEtBQUssQ0FBQztRQUNqQixDQUFDLENBQUMsQ0FBQztRQUVILE9BQU8sT0FBTyxDQUFDO0lBQ2pCLENBQUM7MEVBekNVLGdCQUFnQjtnRUFBaEIsZ0JBQWdCLFdBQWhCLGdCQUFnQjs7aUZBQWhCLGdCQUFnQjtjQUQ1QixVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgRm9ybUFycmF5LCBGb3JtQ29udHJvbCwgRm9ybUdyb3VwIH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xuXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgRm9ybUVycm9yU2VydmljZSB7XG5cbiAgcHVibGljIG1hcEZpZWxkRXJyb3JzKGVycm9yczogeyBpZDogc3RyaW5nOyBtZXNzYWdlOiBzdHJpbmcgfVtdLCBmb3JtOiBGb3JtR3JvdXAsIGVycm9yS2V5OiBzdHJpbmcpOiB2b2lkIHtcblxuICAgIGVycm9ycy5mb3JFYWNoKGVycm9yID0+IHtcbiAgICAgIGNvbnN0IGZvcm1Db250cm9sID0gdGhpcy5nZXRGb3JtQ29udHJvbChmb3JtLCBlcnJvci5pZCk7XG5cbiAgICAgIGlmIChmb3JtQ29udHJvbCkge1xuICAgICAgICBmb3JtQ29udHJvbC5zZXRFcnJvcnMoe1xuICAgICAgICAgIFtlcnJvcktleV06IGVycm9yLm1lc3NhZ2VcbiAgICAgICAgfSk7XG4gICAgICB9XG4gICAgfSk7XG4gIH1cblxuICBwcml2YXRlIGdldEZvcm1Db250cm9sKGZvcm06IEZvcm1Hcm91cCwgZmllbGRJZDogc3RyaW5nKTogRm9ybUNvbnRyb2wge1xuICAgIGNvbnN0IGZpZWxkcyA9IGZpZWxkSWQuc3BsaXQoJy4nKTtcblxuICAgIGxldCBncm91cDogRm9ybUdyb3VwID0gZm9ybTtcbiAgICBsZXQgaW5BcnJheSA9IGZhbHNlO1xuICAgIGxldCBjb250cm9sOiBGb3JtQ29udHJvbDtcbiAgICBmaWVsZHMuZXZlcnkoKGZpZWxkLCBpbmRleCkgPT4ge1xuICAgICAgaWYgKGluZGV4ID09PSBmaWVsZHMubGVuZ3RoIC0gMSkge1xuICAgICAgICBjb250cm9sID0gZ3JvdXAuY29udHJvbHNbZmllbGRdIGFzIEZvcm1Db250cm9sO1xuICAgICAgfSBlbHNlIHtcbiAgICAgICAgZ3JvdXAgPSBncm91cC5jb250cm9sc1tmaWVsZF0gYXMgRm9ybUdyb3VwO1xuXG4gICAgICAgIGlmIChpbkFycmF5ICYmIGdyb3VwLmNvbnRyb2xzWyd2YWx1ZSddKSB7XG4gICAgICAgICAgZ3JvdXAgPSBncm91cC5jb250cm9sc1sndmFsdWUnXSBhcyBGb3JtR3JvdXA7XG4gICAgICAgIH1cblxuICAgICAgICBpZiAoZ3JvdXAgJiYgZ3JvdXAuY29uc3RydWN0b3IgJiYgRm9ybUFycmF5Lm5hbWUgPT09IGdyb3VwLmNvbnN0cnVjdG9yLm5hbWUpIHtcbiAgICAgICAgICBpbkFycmF5ID0gdHJ1ZTtcbiAgICAgICAgfSBlbHNlIHtcbiAgICAgICAgICBpbkFycmF5ID0gZmFsc2U7XG4gICAgICAgIH1cbiAgICAgIH1cbiAgICAgIHJldHVybiAhIWdyb3VwO1xuICAgIH0pO1xuXG4gICAgcmV0dXJuIGNvbnRyb2w7XG4gIH1cbn1cbiJdfQ==

package/esm2022/lib/shared/services/form/form-validators.service.mjs

@@ -0,0 +1,56 @@
+import { Injectable } from '@angular/core';
+import { Validators } from '@angular/forms';
+import { Constants } from '../../commons/constants';
+import * as i0 from "@angular/core";
+export class FormValidatorsService {
+    static CUSTOM_VALIDATED_TYPES = [
+        'Date', 'MoneyGBP', 'Label', 'JudicialUser'
+    ];
+    static addValidators(caseField, control) {
+        if (caseField.display_context === Constants.MANDATORY &&
+            FormValidatorsService.CUSTOM_VALIDATED_TYPES.indexOf(caseField.field_type.type) === -1) {
+            const validators = [Validators.required];
+            if (caseField.field_type.type === 'Text') {
+                if (caseField.field_type.regular_expression) {
+                    validators.push(Validators.pattern(caseField.field_type.regular_expression));
+                }
+                else {
+                    validators.push(this.emptyValidator());
+                }
+                if (caseField.field_type.min && (typeof caseField.field_type.min === 'number')) {
+                    validators.push(Validators.minLength(caseField.field_type.min));
+                }
+                if (caseField.field_type.max && (typeof caseField.field_type.max === 'number')) {
+                    validators.push(Validators.maxLength(caseField.field_type.max));
+                }
+            }
+            if (control.validator) {
+                validators.push(control.validator);
+            }
+            control.setValidators(validators);
+        }
+        return control;
+    }
+    static emptyValidator() {
+        const validator = (control) => {
+            if (control && control.value && control.value.toString().trim().length === 0) {
+                return { required: {} };
+            }
+            return null;
+        };
+        return validator;
+    }
+    // TODO: Strip this out as it's only here for the moment because
+    // the service is being injected all over the place but it doesn't
+    // need to be as FormValidatorsService.addValidators is perfectly
+    // happy being static.
+    addValidators(caseField, control) {
+        return FormValidatorsService.addValidators(caseField, control);
+    }
+    static ɵfac = function FormValidatorsService_Factory(t) { return new (t || FormValidatorsService)(); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: FormValidatorsService, factory: FormValidatorsService.ɵfac });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FormValidatorsService, [{
+        type: Injectable
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,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