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

package/esm2020/lib/shared/directives/conditional-show/services/condition-parser.service.mjs

@@ -0,0 +1,200 @@
+import * as _score from 'underscore';
+import { FieldsUtils } from '../../../services/fields/fields.utils';
+import { ShowCondition } from '../../conditional-show/domain/conditional-show.model';
+import peg from './condition.peg';
+export class ConditionParser {
+    /**
+     * Parse the raw formula and output structured condition data
+     * that can be used in evaluating show/hide logic
+     * @param condition raw formula e.g. TextField = "Hello"
+     */
+    static parse(condition) {
+        if (!condition) {
+            return null;
+        }
+        condition = condition.replace(/CONTAINS/g, ' CONTAINS');
+        return peg.parse(condition.trim(), {});
+    }
+    /**
+     * Evaluate the current fields against the conditions
+     * @param fields the current page fields and their value
+     * @param conditions The PegJS formula output
+     */
+    static evaluate(fields, conditions, path) {
+        if (!conditions || conditions.length === 0) {
+            return true;
+        }
+        const validJoinComparators = ['AND', 'OR'];
+        return conditions.reduce((accumulator, condition, index) => {
+            const isJoinComparator = (comparator) => (typeof comparator === 'string' && validJoinComparators.indexOf(comparator) !== -1);
+            if (isJoinComparator(condition)) {
+                return accumulator;
+            }
+            let currentConditionResult = true;
+            if (Array.isArray(condition)) {
+                currentConditionResult = this.evaluate(fields, condition);
+                if (isJoinComparator(conditions[index - 1])) {
+                    return this.evaluateJoin(accumulator, conditions[index - 1], currentConditionResult);
+                }
+            }
+            if (condition.comparator) {
+                const formula = condition.fieldReference + condition.comparator + condition.value;
+                currentConditionResult = this.matchEqualityCondition(fields, formula, path);
+            }
+            if (isJoinComparator(conditions[index - 1])) {
+                return this.evaluateJoin(accumulator, conditions[index - 1], currentConditionResult);
+            }
+            return currentConditionResult;
+        }, true);
+    }
+    static evaluateJoin(leftResult, comparator, rightResult) {
+        // tslint:disable-next-line:switch-default
+        switch (comparator) {
+            case 'OR': return leftResult || rightResult;
+            case 'AND': return leftResult && rightResult;
+        }
+    }
+    static matchEqualityCondition(fields, condition, path) {
+        const [field, conditionSeparator] = this.getField(condition);
+        const [head, ...tail] = field.split('.');
+        const currentValue = this.findValueForComplexCondition(fields, head, tail, path);
+        const expectedValue = this.unquoted(condition.split(conditionSeparator)[1]);
+        if (conditionSeparator === ShowCondition.CONTAINS) {
+            return this.checkValueContains(expectedValue, currentValue);
+        }
+        else {
+            return this.checkValueEquals(expectedValue, currentValue, conditionSeparator);
+        }
+    }
+    static getValue(fields, head) {
+        if (this.isDynamicList(fields[head])) {
+            return fields[head].value.code;
+        }
+        else {
+            return fields[head];
+        }
+    }
+    static isDynamicList(dynamiclist) {
+        return !_score.isEmpty(dynamiclist) &&
+            (_score.has(dynamiclist, 'value') && _score.has(dynamiclist, 'list_items'));
+    }
+    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 checkValueEquals(expectedValue, currentValue, conditionSeparaor) {
+        if (expectedValue.search('[,]') > -1) { // for  multi-select list
+            return this.checkMultiSelectListEquals(expectedValue, currentValue, conditionSeparaor);
+        }
+        else if (expectedValue.endsWith('*') && currentValue && conditionSeparaor !== ShowCondition.CONDITION_NOT_EQUALS) {
+            if (typeof currentValue === 'string') {
+                return currentValue.startsWith(this.removeStarChar(expectedValue));
+            }
+            return expectedValue === '*';
+        }
+        else {
+            // changed from '===' to '==' to cover number field conditions
+            if (conditionSeparaor === ShowCondition.CONDITION_NOT_EQUALS) {
+                return this.checkValueNotEquals(expectedValue, currentValue);
+            }
+            else {
+                return currentValue == expectedValue || this.okIfBothEmpty(expectedValue, currentValue); // tslint:disable-line
+            }
+        }
+    }
+    static checkValueNotEquals(expectedValue, currentValue) {
+        const formatCurrentValue = currentValue ? currentValue.toString().trim() : '';
+        if ('*' === expectedValue && formatCurrentValue !== '') {
+            return false;
+        }
+        const formatExpectedValue = expectedValue ? expectedValue.toString().trim() : '';
+        return formatCurrentValue != formatExpectedValue; // tslint:disable-line
+    }
+    static checkMultiSelectListEquals(expectedValue, currentValue, conditionSeparator) {
+        const expectedValues = expectedValue.split(',').sort().toString();
+        const values = currentValue ? currentValue.sort().toString() : '';
+        if (conditionSeparator === ShowCondition.CONDITION_NOT_EQUALS) {
+            return expectedValues !== values;
+        }
+        else {
+            return expectedValues === values;
+        }
+    }
+    static checkValueContains(expectedValue, currentValue) {
+        if (expectedValue.search(',') > -1) {
+            const expectedValues = expectedValue.split(',').sort();
+            const values = currentValue ? currentValue.sort().toString() : '';
+            return expectedValues.every(item => values.search(item) >= 0);
+        }
+        else {
+            const values = currentValue && Array.isArray(currentValue) ? currentValue.toString() : '';
+            return values.search(expectedValue) >= 0;
+        }
+    }
+    static unquoted(str) {
+        return str.replace(/^"|"$/g, '');
+    }
+    static findValueForComplexCondition(fields, head, tail, path) {
+        if (!fields) {
+            return undefined;
+        }
+        if (tail.length === 0) {
+            return this.getValue(fields, head);
+        }
+        else {
+            if (FieldsUtils.isArray(fields[head])) {
+                return this.findValueForComplexConditionInArray(fields, head, tail, path);
+            }
+            else {
+                return this.findValueForComplexConditionForPathIfAny(fields, head, tail, path);
+            }
+        }
+    }
+    static findValueForComplexConditionForPathIfAny(fields, head, tail, path) {
+        if (path) {
+            const [_, ...pathTail] = path.split(/[_]+/g);
+            return this.findValueForComplexCondition(fields[head], tail[0], tail.slice(1), pathTail.join('_'));
+        }
+        else if (!fields[head]) {
+            return this.findValueForComplexCondition(fields, tail[0], tail.slice(1), path);
+        }
+        else {
+            return this.findValueForComplexCondition(fields[head], tail[0], tail.slice(1), path);
+        }
+    }
+    static findValueForComplexConditionInArray(fields, head, tail, path) {
+        // use the path to resolve which array element we refer to
+        if (path && path.startsWith(head)) {
+            const [_, ...pathTail] = path.split(/[_]+/g);
+            if (pathTail.length > 0) {
+                try {
+                    const arrayIndex = Number.parseInt(pathTail[0], 10);
+                    const [__, ...dropNumberPath] = pathTail;
+                    return (fields[head][arrayIndex] !== undefined) ? this.findValueForComplexCondition(fields[head][arrayIndex]['value'], tail[0], tail.slice(1), dropNumberPath.join('_')) : null;
+                }
+                catch (e) {
+                    console.error('Error while parsing number', pathTail[0], e);
+                }
+            }
+        }
+        else {
+            console.error('Path in formArray should start with ', head, ', full path: ', path);
+        }
+    }
+    static removeStarChar(str) {
+        if (str && str.indexOf('*') > -1) {
+            return str.substring(0, str.indexOf('*'));
+        }
+        return str;
+    }
+    static okIfBothEmpty(right, value) {
+        return value === null && (right === '');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"condition-parser.service.js","sourceRoot":"","sources":["../../../../../../../../projects/ccd-case-ui-toolkit/src/lib/shared/directives/conditional-show/services/condition-parser.service.ts"],"names":[],"mappings":"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","sourcesContent":["import * as _score from 'underscore';\nimport { FieldsUtils } from '../../../services/fields/fields.utils';\nimport { ShowCondition } from '../../conditional-show/domain/conditional-show.model';\nimport peg from './condition.peg';\n\nexport class ConditionParser {\n  /**\n   * Parse the raw formula and output structured condition data\n   * that can be used in evaluating show/hide logic\n   * @param condition raw formula e.g. TextField = \"Hello\"\n   */\n  public static parse(condition: string): any {\n    if (!condition) { return null; }\n    condition = condition.replace(/CONTAINS/g, ' CONTAINS');\n    return peg.parse(condition.trim(), {});\n  }\n\n  /**\n   * Evaluate the current fields against the conditions\n   * @param fields the current page fields and their value\n   * @param conditions The PegJS formula output\n   */\n  public static evaluate(fields: any, conditions: any[], path?: string): boolean {\n    if (!conditions || conditions.length === 0) { return true; }\n    const validJoinComparators = ['AND', 'OR'];\n\n    return conditions.reduce((accumulator: boolean, condition, index: number) => {\n      const isJoinComparator = (comparator: string): boolean =>\n        (typeof comparator === 'string' && validJoinComparators.indexOf(comparator) !== -1);\n\n      if (isJoinComparator(condition)) { return accumulator; }\n\n      let currentConditionResult = true;\n\n      if (Array.isArray(condition)) {\n        currentConditionResult = this.evaluate(fields, condition);\n\n        if (isJoinComparator(conditions[index - 1])) {\n          return this.evaluateJoin(accumulator, conditions[index - 1], currentConditionResult);\n        }\n      }\n\n      if (condition.comparator) {\n        const formula = condition.fieldReference + condition.comparator + condition.value;\n        currentConditionResult = this.matchEqualityCondition(fields, formula, path);\n      }\n\n      if (isJoinComparator(conditions[index - 1])) {\n        return this.evaluateJoin(accumulator, conditions[index - 1], currentConditionResult);\n      }\n\n      return currentConditionResult;\n    }, true);\n  }\n\n  private static evaluateJoin(leftResult: boolean, comparator, rightResult: boolean): boolean {\n    // tslint:disable-next-line:switch-default\n    switch (comparator) {\n      case 'OR': return leftResult || rightResult;\n      case 'AND': return leftResult && rightResult;\n    }\n  }\n\n  private static matchEqualityCondition(fields: object, condition: string, path?: string): boolean {\n    const [field, conditionSeparator] = this.getField(condition);\n    const [head, ...tail] = field.split('.');\n    const currentValue = this.findValueForComplexCondition(fields, head, tail, path);\n    const expectedValue = this.unquoted(condition.split(conditionSeparator)[1]);\n    if (conditionSeparator === ShowCondition.CONTAINS) {\n      return this.checkValueContains(expectedValue, currentValue);\n    } else {\n      return this.checkValueEquals(expectedValue, currentValue, conditionSeparator);\n    }\n  }\n\n  private static getValue(fields: object, head: string): any {\n    if (this.isDynamicList(fields[head])) {\n      return fields[head].value.code;\n    } else {\n      return fields[head];\n    }\n  }\n\n  private static isDynamicList(dynamiclist: object): boolean {\n    return !_score.isEmpty(dynamiclist) &&\n        (_score.has(dynamiclist, 'value') && _score.has(dynamiclist, 'list_items'));\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 checkValueEquals(expectedValue: string, currentValue: any, conditionSeparaor: string): boolean {\n    if (expectedValue.search('[,]') > -1) { // for  multi-select list\n      return this.checkMultiSelectListEquals(expectedValue, currentValue, conditionSeparaor);\n    } else if (expectedValue.endsWith('*') && currentValue && conditionSeparaor !== ShowCondition.CONDITION_NOT_EQUALS) {\n      if (typeof currentValue === 'string') {\n        return currentValue.startsWith(this.removeStarChar(expectedValue));\n      }\n      return expectedValue === '*';\n    } else {\n      // changed from '===' to '==' to cover number field conditions\n      if (conditionSeparaor === ShowCondition.CONDITION_NOT_EQUALS) {\n        return this.checkValueNotEquals(expectedValue, currentValue);\n      } else {\n        return currentValue == expectedValue || this.okIfBothEmpty(expectedValue, currentValue); // tslint:disable-line\n      }\n    }\n  }\n\n  private static checkValueNotEquals(expectedValue: string, currentValue: any): boolean {\n    const formatCurrentValue = currentValue ? currentValue.toString().trim() : '';\n    if ('*' === expectedValue && formatCurrentValue !== '') {\n      return false;\n    }\n    const formatExpectedValue = expectedValue ? expectedValue.toString().trim() : '';\n    return formatCurrentValue != formatExpectedValue; // tslint:disable-line\n  }\n\n  private static checkMultiSelectListEquals(expectedValue: string, currentValue: any, conditionSeparator: string): boolean {\n    const expectedValues = expectedValue.split(',').sort().toString();\n    const values = currentValue ? currentValue.sort().toString() : '';\n    if (conditionSeparator === ShowCondition.CONDITION_NOT_EQUALS) {\n      return expectedValues !== values;\n    } else {\n      return expectedValues === values;\n    }\n  }\n\n  private static checkValueContains(expectedValue: string, currentValue: any): boolean {\n    if (expectedValue.search(',') > -1) {\n      const expectedValues = expectedValue.split(',').sort();\n      const values = currentValue ? currentValue.sort().toString() : '';\n      return expectedValues.every(item => values.search(item) >= 0);\n    } else {\n      const values = currentValue && Array.isArray(currentValue) ? currentValue.toString() : '';\n      return values.search(expectedValue) >= 0;\n    }\n  }\n\n  private static unquoted(str: string): string {\n    return str.replace(/^\"|\"$/g, '');\n  }\n\n  private static findValueForComplexCondition(fields: object, head: string, tail: string[], path?: string): any {\n    if (!fields) {\n      return undefined;\n    }\n    if (tail.length === 0) {\n      return this.getValue(fields, head);\n    } else {\n      if (FieldsUtils.isArray(fields[head])) {\n        return this.findValueForComplexConditionInArray(fields, head, tail, path);\n      } else {\n        return this.findValueForComplexConditionForPathIfAny(fields, head, tail, path);\n      }\n    }\n  }\n\n  private static findValueForComplexConditionForPathIfAny(fields: object, head: string, tail: string[], path?: string): any {\n    if (path) {\n      const [_, ...pathTail] = path.split(/[_]+/g);\n      return this.findValueForComplexCondition(fields[head], tail[0], tail.slice(1), pathTail.join('_'));\n    } else if (!fields[head]) {\n      return this.findValueForComplexCondition(fields, tail[0], tail.slice(1), path);\n    } else {\n      return this.findValueForComplexCondition(fields[head], tail[0], tail.slice(1), path);\n    }\n  }\n\n  private static findValueForComplexConditionInArray(fields: object, head: string, tail: string[], path?: string): any {\n    // use the path to resolve which array element we refer to\n    if (path && path.startsWith(head)) {\n      const [_, ...pathTail] = path.split(/[_]+/g);\n      if (pathTail.length > 0) {\n        try {\n          const arrayIndex = Number.parseInt(pathTail[0], 10);\n          const [__, ...dropNumberPath] = pathTail;\n          return (fields[head][arrayIndex] !== undefined) ? this.findValueForComplexCondition(\n            fields[head][arrayIndex]['value'], tail[0], tail.slice(1), dropNumberPath.join('_')) : null;\n        } catch (e) {\n          console.error('Error while parsing number', pathTail[0], e);\n        }\n      }\n    } else {\n      console.error('Path in formArray should start with ', head, ', full path: ', path);\n    }\n  }\n\n  private static removeStarChar(str: string): string {\n    if (str && str.indexOf('*') > -1) {\n      return str.substring(0, str.indexOf('*'));\n    }\n    return str;\n  }\n\n  private static okIfBothEmpty(right: string, value: any): boolean {\n    return value === null && (right === '');\n  }\n}\n"]}

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

@@ -0,0 +1,19 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ConditionalShowRegistrarService {
+    constructor() {
+        this.registeredDirectives = [];
+    }
+    register(newDirective) {
+        this.registeredDirectives.push(newDirective);
+    }
+    reset() {
+        this.registeredDirectives = [];
+    }
+}
+ConditionalShowRegistrarService.ɵfac = function ConditionalShowRegistrarService_Factory(t) { return new (t || ConditionalShowRegistrarService)(); };
+ConditionalShowRegistrarService.ɵ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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZGl0aW9uYWwtc2hvdy1yZWdpc3RyYXIuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NjZC1jYXNlLXVpLXRvb2xraXQvc3JjL2xpYi9zaGFyZWQvZGlyZWN0aXZlcy9jb25kaXRpb25hbC1zaG93L3NlcnZpY2VzL2NvbmRpdGlvbmFsLXNob3ctcmVnaXN0cmFyLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFJM0MsTUFBTSxPQUFPLCtCQUErQjtJQUQ1QztRQUVTLHlCQUFvQixHQUFtQyxFQUFFLENBQUM7S0FTbEU7SUFQUSxRQUFRLENBQUMsWUFBMEM7UUFDdEQsSUFBSSxDQUFDLG9CQUFvQixDQUFDLElBQUksQ0FBQyxZQUFZLENBQUMsQ0FBQztJQUNqRCxDQUFDO0lBRU0sS0FBSztRQUNWLElBQUksQ0FBQyxvQkFBb0IsR0FBRyxFQUFFLENBQUM7SUFDakMsQ0FBQzs7OEdBVFUsK0JBQStCO3FGQUEvQiwrQkFBK0IsV0FBL0IsK0JBQStCO3VGQUEvQiwrQkFBK0I7Y0FEM0MsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IENvbmRpdGlvbmFsU2hvd0Zvcm1EaXJlY3RpdmUgfSBmcm9tICcuLi9jb25kaXRpb25hbC1zaG93LWZvcm0uZGlyZWN0aXZlJztcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIENvbmRpdGlvbmFsU2hvd1JlZ2lzdHJhclNlcnZpY2Uge1xuICBwdWJsaWMgcmVnaXN0ZXJlZERpcmVjdGl2ZXM6IENvbmRpdGlvbmFsU2hvd0Zvcm1EaXJlY3RpdmVbXSA9IFtdO1xuXG4gIHB1YmxpYyByZWdpc3RlcihuZXdEaXJlY3RpdmU6IENvbmRpdGlvbmFsU2hvd0Zvcm1EaXJlY3RpdmUpOiB2b2lkIHtcbiAgICAgIHRoaXMucmVnaXN0ZXJlZERpcmVjdGl2ZXMucHVzaChuZXdEaXJlY3RpdmUpO1xuICB9XG5cbiAgcHVibGljIHJlc2V0KCk6IHZvaWQge1xuICAgIHRoaXMucmVnaXN0ZXJlZERpcmVjdGl2ZXMgPSBbXTtcbiAgfVxufVxuIl19

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

@@ -0,0 +1,47 @@
+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 {
+    constructor(rendererFactory) {
+        this.fieldsToggledToShow = [];
+        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');
+        }
+    }
+}
+GreyBarService.ɵfac = function GreyBarService_Factory(t) { return new (t || GreyBarService)(i0.ɵɵinject(i0.RendererFactory2)); };
+GreyBarService.ɵ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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

package/esm2020/lib/shared/directives/focus-element/focus-element.directive.mjs

@@ -0,0 +1,36 @@
+import { Directive, ElementRef, Renderer2 } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Focuses the host element after the content of the view has been initialised. Works on writable fields. If the
+ * directive is used on more than one element, the last element to be initialised will be in focus.
+ * NOTE:
+ * The directive focuses on the element only for the very first time when the content into the component's view, the
+ * view that the directive is in is initialised. Refocusing the element will require explicit focusing for e.g. by
+ * calling this directives focus() method from the host component.
+ */
+export class FocusElementDirective {
+    constructor(el, renderer) {
+        this.el = el;
+        this.renderer = renderer;
+    }
+    ngAfterContentInit() {
+        this.focus();
+    }
+    focus() {
+        if (this.el.nativeElement) {
+            const focusElement = this.renderer.selectRootElement(this.el.nativeElement, true);
+            if (focusElement) {
+                focusElement.focus();
+            }
+        }
+    }
+}
+FocusElementDirective.ɵfac = function FocusElementDirective_Factory(t) { return new (t || FocusElementDirective)(i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.Renderer2)); };
+FocusElementDirective.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: FocusElementDirective, selectors: [["", "focusElement", ""]] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FocusElementDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[focusElement]'
+            }]
+    }], function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9jdXMtZWxlbWVudC5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jY2QtY2FzZS11aS10b29sa2l0L3NyYy9saWIvc2hhcmVkL2RpcmVjdGl2ZXMvZm9jdXMtZWxlbWVudC9mb2N1cy1lbGVtZW50LmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQW9CLFNBQVMsRUFBRSxVQUFVLEVBQUUsU0FBUyxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUtuRjs7Ozs7OztHQU9HO0FBQ0gsTUFBTSxPQUFPLHFCQUFxQjtJQUVoQyxZQUE2QixFQUFjLEVBQW1CLFFBQW1CO1FBQXBELE9BQUUsR0FBRixFQUFFLENBQVk7UUFBbUIsYUFBUSxHQUFSLFFBQVEsQ0FBVztJQUNqRixDQUFDO0lBRU0sa0JBQWtCO1FBQ3ZCLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztJQUNmLENBQUM7SUFFTSxLQUFLO1FBQ1YsSUFBSSxJQUFJLENBQUMsRUFBRSxDQUFDLGFBQWEsRUFBRTtZQUN6QixNQUFNLFlBQVksR0FBRyxJQUFJLENBQUMsUUFBUSxDQUFDLGlCQUFpQixDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsYUFBYSxFQUFFLElBQUksQ0FBQyxDQUFDO1lBQ2xGLElBQUksWUFBWSxFQUFFO2dCQUNoQixZQUFZLENBQUMsS0FBSyxFQUFFLENBQUM7YUFDdEI7U0FDRjtJQUNILENBQUM7OzBGQWhCVSxxQkFBcUI7d0VBQXJCLHFCQUFxQjt1RkFBckIscUJBQXFCO2NBWGpDLFNBQVM7ZUFBQztnQkFDVCxRQUFRLEVBQUUsZ0JBQWdCO2FBQzNCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQWZ0ZXJDb250ZW50SW5pdCwgRGlyZWN0aXZlLCBFbGVtZW50UmVmLCBSZW5kZXJlcjIgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQERpcmVjdGl2ZSh7XG4gIHNlbGVjdG9yOiAnW2ZvY3VzRWxlbWVudF0nXG59KVxuLyoqXG4gKiBGb2N1c2VzIHRoZSBob3N0IGVsZW1lbnQgYWZ0ZXIgdGhlIGNvbnRlbnQgb2YgdGhlIHZpZXcgaGFzIGJlZW4gaW5pdGlhbGlzZWQuIFdvcmtzIG9uIHdyaXRhYmxlIGZpZWxkcy4gSWYgdGhlXG4gKiBkaXJlY3RpdmUgaXMgdXNlZCBvbiBtb3JlIHRoYW4gb25lIGVsZW1lbnQsIHRoZSBsYXN0IGVsZW1lbnQgdG8gYmUgaW5pdGlhbGlzZWQgd2lsbCBiZSBpbiBmb2N1cy5cbiAqIE5PVEU6XG4gKiBUaGUgZGlyZWN0aXZlIGZvY3VzZXMgb24gdGhlIGVsZW1lbnQgb25seSBmb3IgdGhlIHZlcnkgZmlyc3QgdGltZSB3aGVuIHRoZSBjb250ZW50IGludG8gdGhlIGNvbXBvbmVudCdzIHZpZXcsIHRoZVxuICogdmlldyB0aGF0IHRoZSBkaXJlY3RpdmUgaXMgaW4gaXMgaW5pdGlhbGlzZWQuIFJlZm9jdXNpbmcgdGhlIGVsZW1lbnQgd2lsbCByZXF1aXJlIGV4cGxpY2l0IGZvY3VzaW5nIGZvciBlLmcuIGJ5XG4gKiBjYWxsaW5nIHRoaXMgZGlyZWN0aXZlcyBmb2N1cygpIG1ldGhvZCBmcm9tIHRoZSBob3N0IGNvbXBvbmVudC5cbiAqL1xuZXhwb3J0IGNsYXNzIEZvY3VzRWxlbWVudERpcmVjdGl2ZSBpbXBsZW1lbnRzIEFmdGVyQ29udGVudEluaXQge1xuXG4gIGNvbnN0cnVjdG9yKHByaXZhdGUgcmVhZG9ubHkgZWw6IEVsZW1lbnRSZWYsIHByaXZhdGUgcmVhZG9ubHkgcmVuZGVyZXI6IFJlbmRlcmVyMikge1xuICB9XG5cbiAgcHVibGljIG5nQWZ0ZXJDb250ZW50SW5pdCgpOiB2b2lkIHtcbiAgICB0aGlzLmZvY3VzKCk7XG4gIH1cblxuICBwdWJsaWMgZm9jdXMoKTogdm9pZCB7XG4gICAgaWYgKHRoaXMuZWwubmF0aXZlRWxlbWVudCkge1xuICAgICAgY29uc3QgZm9jdXNFbGVtZW50ID0gdGhpcy5yZW5kZXJlci5zZWxlY3RSb290RWxlbWVudCh0aGlzLmVsLm5hdGl2ZUVsZW1lbnQsIHRydWUpO1xuICAgICAgaWYgKGZvY3VzRWxlbWVudCkge1xuICAgICAgICBmb2N1c0VsZW1lbnQuZm9jdXMoKTtcbiAgICAgIH1cbiAgICB9XG4gIH1cblxufVxuIl19

package/esm2020/lib/shared/directives/focus-element/focus-element.module.mjs

@@ -0,0 +1,21 @@
+import { NgModule } from '@angular/core';
+import { FocusElementDirective } from './focus-element.directive';
+import * as i0 from "@angular/core";
+export class FocusElementModule {
+}
+FocusElementModule.ɵfac = function FocusElementModule_Factory(t) { return new (t || FocusElementModule)(); };
+FocusElementModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: FocusElementModule });
+FocusElementModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({});
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FocusElementModule, [{
+        type: NgModule,
+        args: [{
+                declarations: [
+                    FocusElementDirective
+                ],
+                exports: [
+                    FocusElementDirective
+                ]
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(FocusElementModule, { declarations: [FocusElementDirective], exports: [FocusElementDirective] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9jdXMtZWxlbWVudC5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jY2QtY2FzZS11aS10b29sa2l0L3NyYy9saWIvc2hhcmVkL2RpcmVjdGl2ZXMvZm9jdXMtZWxlbWVudC9mb2N1cy1lbGVtZW50Lm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDJCQUEyQixDQUFDOztBQVVsRSxNQUFNLE9BQU8sa0JBQWtCOztvRkFBbEIsa0JBQWtCO29FQUFsQixrQkFBa0I7O3VGQUFsQixrQkFBa0I7Y0FSOUIsUUFBUTtlQUFDO2dCQUNSLFlBQVksRUFBRTtvQkFDWixxQkFBcUI7aUJBQ3RCO2dCQUNELE9BQU8sRUFBRTtvQkFDUCxxQkFBcUI7aUJBQ3RCO2FBQ0Y7O3dGQUNZLGtCQUFrQixtQkFOM0IscUJBQXFCLGFBR3JCLHFCQUFxQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBGb2N1c0VsZW1lbnREaXJlY3RpdmUgfSBmcm9tICcuL2ZvY3VzLWVsZW1lbnQuZGlyZWN0aXZlJztcblxuQE5nTW9kdWxlKHtcbiAgZGVjbGFyYXRpb25zOiBbXG4gICAgRm9jdXNFbGVtZW50RGlyZWN0aXZlXG4gIF0sXG4gIGV4cG9ydHM6IFtcbiAgICBGb2N1c0VsZW1lbnREaXJlY3RpdmVcbiAgXVxufSlcbmV4cG9ydCBjbGFzcyBGb2N1c0VsZW1lbnRNb2R1bGUge1xufVxuIl19

package/esm2020/lib/shared/directives/substitutor/label-substitutor.directive.mjs

@@ -0,0 +1,82 @@
+import { Directive, Input } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { CaseField } from '../../domain/definition/case-field.model';
+import { FieldsUtils } from '../../services/fields/fields.utils';
+import { PlaceholderService } from './services/placeholder.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/fields/fields.utils";
+import * as i2 from "./services/placeholder.service";
+/**
+ * Checks all labels and substitutes any placholders that reference other fields values.
+ */
+export class LabelSubstitutorDirective {
+    constructor(fieldsUtils, placeholderService) {
+        this.fieldsUtils = fieldsUtils;
+        this.placeholderService = placeholderService;
+        this.contextFields = [];
+        this.elementsToSubstitute = ['label', 'hint_text'];
+    }
+    ngOnInit() {
+        this.initialLabel = this.caseField.label;
+        this.initialHintText = this.caseField.hint_text;
+        this.formGroup = this.formGroup || new FormGroup({});
+        const fields = this.getReadOnlyAndFormFields();
+        if (this.shouldSubstitute('label')) {
+            this.caseField.label = this.resolvePlaceholders(fields, this.caseField.label);
+        }
+        if (this.shouldSubstitute('hint_text')) {
+            this.caseField.hint_text = this.resolvePlaceholders(fields, this.caseField.hint_text);
+        }
+        if (this.shouldSubstitute('value')) {
+            this.caseField.value = this.resolvePlaceholders(fields, this.caseField.value);
+        }
+    }
+    ngOnDestroy() {
+        if (this.initialLabel) {
+            this.caseField.label = this.initialLabel;
+        }
+        if (this.initialHintText) {
+            this.caseField.hint_text = this.initialHintText;
+        }
+    }
+    shouldSubstitute(element) {
+        return this.elementsToSubstitute.find(e => e === element) !== undefined;
+    }
+    getReadOnlyAndFormFields() {
+        const formFields = this.getFormFieldsValuesIncludingDisabled();
+        // TODO: Delete following line when @Input contextFields is fixed - https://tools.hmcts.net/jira/browse/RDM-3504
+        const uniqueContextFields = this.removeDuplicates(this.contextFields);
+        return this.fieldsUtils.mergeLabelCaseFieldsAndFormFields(uniqueContextFields, formFields);
+    }
+    removeDuplicates(original) {
+        const unique = [];
+        original.forEach(caseField => {
+            const isUnique = unique.filter(e => e.id === caseField.id).length === 0;
+            if (isUnique) {
+                unique.push(caseField);
+            }
+        });
+        return unique;
+    }
+    getFormFieldsValuesIncludingDisabled() {
+        return this.formGroup.getRawValue();
+    }
+    resolvePlaceholders(fields, stringToResolve) {
+        return this.placeholderService.resolvePlaceholders(fields, stringToResolve);
+    }
+}
+LabelSubstitutorDirective.ɵfac = function LabelSubstitutorDirective_Factory(t) { return new (t || LabelSubstitutorDirective)(i0.ɵɵdirectiveInject(i1.FieldsUtils), i0.ɵɵdirectiveInject(i2.PlaceholderService)); };
+LabelSubstitutorDirective.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: LabelSubstitutorDirective, selectors: [["", "ccdLabelSubstitutor", ""]], inputs: { caseField: "caseField", contextFields: "contextFields", formGroup: "formGroup", elementsToSubstitute: "elementsToSubstitute" } });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LabelSubstitutorDirective, [{
+        type: Directive,
+        args: [{ selector: '[ccdLabelSubstitutor]' }]
+    }], function () { return [{ type: i1.FieldsUtils }, { type: i2.PlaceholderService }]; }, { caseField: [{
+            type: Input
+        }], contextFields: [{
+            type: Input
+        }], formGroup: [{
+            type: Input
+        }], elementsToSubstitute: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/shared/directives/substitutor/label-substitutor.module.mjs

@@ -0,0 +1,30 @@
+import { CurrencyPipe } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FieldsUtils } from '../../services/fields/fields.utils';
+import { LabelSubstitutorDirective } from './label-substitutor.directive';
+import * as i0 from "@angular/core";
+export class LabelSubstitutorModule {
+}
+LabelSubstitutorModule.ɵfac = function LabelSubstitutorModule_Factory(t) { return new (t || LabelSubstitutorModule)(); };
+LabelSubstitutorModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: LabelSubstitutorModule });
+LabelSubstitutorModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ providers: [
+        FieldsUtils,
+        CurrencyPipe,
+    ] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LabelSubstitutorModule, [{
+        type: NgModule,
+        args: [{
+                declarations: [
+                    LabelSubstitutorDirective
+                ],
+                exports: [
+                    LabelSubstitutorDirective
+                ],
+                providers: [
+                    FieldsUtils,
+                    CurrencyPipe,
+                ]
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(LabelSubstitutorModule, { declarations: [LabelSubstitutorDirective], exports: [LabelSubstitutorDirective] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGFiZWwtc3Vic3RpdHV0b3IubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2NkLWNhc2UtdWktdG9vbGtpdC9zcmMvbGliL3NoYXJlZC9kaXJlY3RpdmVzL3N1YnN0aXR1dG9yL2xhYmVsLXN1YnN0aXR1dG9yLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sb0NBQW9DLENBQUM7QUFDakUsT0FBTyxFQUFFLHlCQUF5QixFQUFFLE1BQU0sK0JBQStCLENBQUM7O0FBYzFFLE1BQU0sT0FBTyxzQkFBc0I7OzRGQUF0QixzQkFBc0I7d0VBQXRCLHNCQUFzQjs2RUFMdEI7UUFDVCxXQUFXO1FBQ1gsWUFBWTtLQUNiO3VGQUVVLHNCQUFzQjtjQVpsQyxRQUFRO2VBQUM7Z0JBQ1IsWUFBWSxFQUFFO29CQUNaLHlCQUF5QjtpQkFDMUI7Z0JBQ0QsT0FBTyxFQUFFO29CQUNQLHlCQUF5QjtpQkFDMUI7Z0JBQ0QsU0FBUyxFQUFFO29CQUNULFdBQVc7b0JBQ1gsWUFBWTtpQkFDYjthQUNGOzt3RkFDWSxzQkFBc0IsbUJBVi9CLHlCQUF5QixhQUd6Qix5QkFBeUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDdXJyZW5jeVBpcGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEZpZWxkc1V0aWxzIH0gZnJvbSAnLi4vLi4vc2VydmljZXMvZmllbGRzL2ZpZWxkcy51dGlscyc7XG5pbXBvcnQgeyBMYWJlbFN1YnN0aXR1dG9yRGlyZWN0aXZlIH0gZnJvbSAnLi9sYWJlbC1zdWJzdGl0dXRvci5kaXJlY3RpdmUnO1xuXG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IFtcbiAgICBMYWJlbFN1YnN0aXR1dG9yRGlyZWN0aXZlXG4gIF0sXG4gIGV4cG9ydHM6IFtcbiAgICBMYWJlbFN1YnN0aXR1dG9yRGlyZWN0aXZlXG4gIF0sXG4gIHByb3ZpZGVyczogW1xuICAgIEZpZWxkc1V0aWxzLFxuICAgIEN1cnJlbmN5UGlwZSxcbiAgXVxufSlcbmV4cG9ydCBjbGFzcyBMYWJlbFN1YnN0aXR1dG9yTW9kdWxlIHt9XG4iXX0=