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

package/esm2022/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/esm2022/lib/shared/directives/conditional-show/services/conditional-show-registrar.service.mjs

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

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

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

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

@@ -0,0 +1,38 @@
+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 {
+    el;
+    renderer;
+    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();
+            }
+        }
+    }
+    static ɵfac = function FocusElementDirective_Factory(t) { return new (t || FocusElementDirective)(i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.Renderer2)); };
+    static ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: FocusElementDirective, selectors: [["", "focusElement", ""]] });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FocusElementDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[focusElement]'
+            }]
+    }], () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/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 {
+    static ɵfac = function FocusElementModule_Factory(t) { return new (t || FocusElementModule)(); };
+    static ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: FocusElementModule });
+    static ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({});
+}
+(() => { (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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9jdXMtZWxlbWVudC5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jY2QtY2FzZS11aS10b29sa2l0L3NyYy9saWIvc2hhcmVkL2RpcmVjdGl2ZXMvZm9jdXMtZWxlbWVudC9mb2N1cy1lbGVtZW50Lm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDJCQUEyQixDQUFDOztBQVVsRSxNQUFNLE9BQU8sa0JBQWtCOzRFQUFsQixrQkFBa0I7NERBQWxCLGtCQUFrQjs7O2lGQUFsQixrQkFBa0I7Y0FSOUIsUUFBUTtlQUFDO2dCQUNSLFlBQVksRUFBRTtvQkFDWixxQkFBcUI7aUJBQ3RCO2dCQUNELE9BQU8sRUFBRTtvQkFDUCxxQkFBcUI7aUJBQ3RCO2FBQ0Y7O3dGQUNZLGtCQUFrQixtQkFOM0IscUJBQXFCLGFBR3JCLHFCQUFxQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBGb2N1c0VsZW1lbnREaXJlY3RpdmUgfSBmcm9tICcuL2ZvY3VzLWVsZW1lbnQuZGlyZWN0aXZlJztcblxuQE5nTW9kdWxlKHtcbiAgZGVjbGFyYXRpb25zOiBbXG4gICAgRm9jdXNFbGVtZW50RGlyZWN0aXZlXG4gIF0sXG4gIGV4cG9ydHM6IFtcbiAgICBGb2N1c0VsZW1lbnREaXJlY3RpdmVcbiAgXVxufSlcbmV4cG9ydCBjbGFzcyBGb2N1c0VsZW1lbnRNb2R1bGUge1xufVxuIl19

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

@@ -0,0 +1,88 @@
+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 {
+    fieldsUtils;
+    placeholderService;
+    caseField;
+    contextFields = [];
+    formGroup;
+    elementsToSubstitute = ['label', 'hint_text'];
+    initialLabel;
+    initialHintText;
+    constructor(fieldsUtils, placeholderService) {
+        this.fieldsUtils = fieldsUtils;
+        this.placeholderService = placeholderService;
+    }
+    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);
+    }
+    static ɵfac = function LabelSubstitutorDirective_Factory(t) { return new (t || LabelSubstitutorDirective)(i0.ɵɵdirectiveInject(i1.FieldsUtils), i0.ɵɵdirectiveInject(i2.PlaceholderService)); };
+    static ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: LabelSubstitutorDirective, selectors: [["", "ccdLabelSubstitutor", ""]], inputs: { caseField: "caseField", contextFields: "contextFields", formGroup: "formGroup", elementsToSubstitute: "elementsToSubstitute" } });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LabelSubstitutorDirective, [{
+        type: Directive,
+        args: [{ selector: '[ccdLabelSubstitutor]' }]
+    }], () => [{ 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/esm2022/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 {
+    static ɵfac = function LabelSubstitutorModule_Factory(t) { return new (t || LabelSubstitutorModule)(); };
+    static ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: LabelSubstitutorModule });
+    static ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ providers: [
+            FieldsUtils,
+            CurrencyPipe,
+        ] });
+}
+(() => { (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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGFiZWwtc3Vic3RpdHV0b3IubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2NkLWNhc2UtdWktdG9vbGtpdC9zcmMvbGliL3NoYXJlZC9kaXJlY3RpdmVzL3N1YnN0aXR1dG9yL2xhYmVsLXN1YnN0aXR1dG9yLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sb0NBQW9DLENBQUM7QUFDakUsT0FBTyxFQUFFLHlCQUF5QixFQUFFLE1BQU0sK0JBQStCLENBQUM7O0FBYzFFLE1BQU0sT0FBTyxzQkFBc0I7Z0ZBQXRCLHNCQUFzQjs0REFBdEIsc0JBQXNCO2lFQUx0QjtZQUNULFdBQVc7WUFDWCxZQUFZO1NBQ2I7O2lGQUVVLHNCQUFzQjtjQVpsQyxRQUFRO2VBQUM7Z0JBQ1IsWUFBWSxFQUFFO29CQUNaLHlCQUF5QjtpQkFDMUI7Z0JBQ0QsT0FBTyxFQUFFO29CQUNQLHlCQUF5QjtpQkFDMUI7Z0JBQ0QsU0FBUyxFQUFFO29CQUNULFdBQVc7b0JBQ1gsWUFBWTtpQkFDYjthQUNGOzt3RkFDWSxzQkFBc0IsbUJBVi9CLHlCQUF5QixhQUd6Qix5QkFBeUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDdXJyZW5jeVBpcGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEZpZWxkc1V0aWxzIH0gZnJvbSAnLi4vLi4vc2VydmljZXMvZmllbGRzL2ZpZWxkcy51dGlscyc7XG5pbXBvcnQgeyBMYWJlbFN1YnN0aXR1dG9yRGlyZWN0aXZlIH0gZnJvbSAnLi9sYWJlbC1zdWJzdGl0dXRvci5kaXJlY3RpdmUnO1xuXG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IFtcbiAgICBMYWJlbFN1YnN0aXR1dG9yRGlyZWN0aXZlXG4gIF0sXG4gIGV4cG9ydHM6IFtcbiAgICBMYWJlbFN1YnN0aXR1dG9yRGlyZWN0aXZlXG4gIF0sXG4gIHByb3ZpZGVyczogW1xuICAgIEZpZWxkc1V0aWxzLFxuICAgIEN1cnJlbmN5UGlwZSxcbiAgXVxufSlcbmV4cG9ydCBjbGFzcyBMYWJlbFN1YnN0aXR1dG9yTW9kdWxlIHt9XG4iXX0=