@pega/angular-sdk-components 0.23.1

package/README.md

@@ -0,0 +1,24 @@
+# AngularSdkComponents
+
+This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 16.2.0.
+
+## Code scaffolding
+
+Run `ng generate component component-name --project angular-sdk-components` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module --project angular-sdk-components`.
+> Note: Don't forget to add `--project angular-sdk-components` or else it will be added to the default project in your `angular.json` file.
+
+## Build
+
+Run `ng build angular-sdk-components` to build the project. The build artifacts will be stored in the `dist/` directory.
+
+## Publishing
+
+After building your library with `ng build angular-sdk-components`, go to the dist folder `cd dist/angular-sdk-components` and run `npm publish`.
+
+## Running unit tests
+
+Run `ng test angular-sdk-components` to execute the unit tests via [Karma](https://karma-runner.github.io).
+
+## Further help
+
+To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI Overview and Command Reference](https://angular.io/cli) page.

package/_shared/styles.scss

@@ -0,0 +1,28 @@
+$app-primary-color: #673ab7;
+$app-primary-dark-color: #4527a0;
+$app-primary-light-color: #b499fc;
+$app-secondary-color: #ffc400;
+$app-neutral-color: grey;
+$app-neutral-light-color: lightgrey;
+$app-neutral-dark-color: #262626;
+$app-error-light-color: #e57373;
+$app-warning-color: #ff9800;
+$app-warning-color-dark: #f57c00;
+
+$app-background-color: whitesmoke;
+$app-form-color: white;
+
+// svg filter colors that match above, go here to generate https://codepen.io/sosuke/pen/Pjoqqp
+$app-primary-color-filter: invert(23%) sepia(23%) saturate(6785%) hue-rotate(250deg) brightness(93%) contrast(88%);
+$app-primary-dark-color-filter: invert(19%) sepia(20%) saturate(6809%) hue-rotate(242deg) brightness(100%) contrast(106%);
+$app-secondary-color-filter: invert(83%) sepia(31%) saturate(4626%) hue-rotate(360deg) brightness(103%) contrast(104%);
+$app-neutral-color-filter: invert(55%) sepia(25%) saturate(0%) hue-rotate(269deg) brightness(87%) contrast(91%);
+$app-neutral-light-color-filter: invert(69%) sepia(74%) saturate(0%) hue-rotate(205deg) brightness(102%) contrast(103%);
+$app-white-color-filter: invert(100%) sepia(99%) saturate(0%) hue-rotate(144deg) brightness(109%) contrast(101%);
+
+// App Navigation
+$app-nav-bg: #262626 !default;
+$app-nav-color: invert($app-nav-bg) !default;
+$app-nav-width: 5rem !default;
+// $app-nav-width: 15.625rem !default;
+$app-nav-width-expanded: 15.625rem !default;

package/esm2022/lib/_bridge/angular-pconnect.mjs

@@ -0,0 +1,416 @@
+import { Injectable } from '@angular/core';
+import { interval } from 'rxjs';
+import isEqual from 'fast-deep-equal';
+import { Utils } from '../_helpers/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../_messages/progress-spinner.service";
+import * as i2 from "../_messages/error-messages.service";
+import * as i3 from "../_helpers/utils";
+export class AngularPConnectService {
+    /* Used to toggle some class-wide logging */
+    static { this.bLogging = false; }
+    constructor(psService, erService, utils) {
+        this.psService = psService;
+        this.erService = erService;
+        this.utils = utils;
+        /**
+         * Local variable for access to the store once the service is connected to it.
+         */
+        this.theStore = null;
+        /**
+         * Local variable used to compute the next componentID
+         */
+        this.counterComponentID = 0;
+        /**
+         * Local array used to store the association of an component to its most recent "props"
+         *  where "props" is the object containing the component's getConfigProps along with
+         * anything added by populateAdditionalProps.
+         * Each entry is: { __componentID__: _the component's most recent props_ }
+         */
+        this.componentPropsArr = [];
+        // Establish necessary override flags for our use of Core
+        // const coreOverrides = { "dynamicLoadComponents": false };
+        // let coreOverrides = PCore.getBehaviorOverrides();
+        // coreOverrides["dynamicLoadComponents"] = false;
+        // PCore.setBehaviorOverrides( coreOverrides );
+        PCore.setBehaviorOverride('dynamicLoadComponents', false);
+        // Always best to use deep object compare when it's available
+        // if (isEqual !== undefined) {
+        // console.log(`AngularPConnect is using deep object compare`);
+        // } else {
+        // console.log(`AngularPConnect is using JSON.stringify compare`);
+        // }
+    }
+    /**
+     * Returns a unique (for this session) ComponentID that should
+     * be used for that component to update its most recent props
+     * (which can also be compared against its previous value
+     * before updating). Note that this returns a string so we can use
+     * it as a key in an associative array
+     * @returns the next componentID
+     */
+    getNextComponentId() {
+        this.counterComponentID += 1;
+        // Note that we use the string version of the number so we have an
+        //  associative array that we can clean up later, if needed.
+        return this.counterComponentID.toString();
+    }
+    /**
+     * The Calling object (inComp) subscribes to store changes.
+     * @param inComp The component that's subscribing to the store
+     * @param inCallback The component's callback function (typically called onStateChange) that will
+     * be called when the store changes.
+     * @returns The **unsubscribe** function that should be called when the component needs
+     * to unsubscribe from the store. (Typically during ngOnDestroy)
+     */
+    subscribeToStore(inComp = null, inCallback = null) {
+        // const theCompName: string = inComp ? `${inComp.constructor.name}` : 'no component provided';
+        let fnUnsubscribe;
+        // console.log( `Bridge subscribing: ${theCompName} `);
+        if (inComp) {
+            fnUnsubscribe = this.getStore().subscribe(inCallback);
+        }
+        return fnUnsubscribe;
+    }
+    /**
+     * Gets the Component's properties that are used (a) to populate componentPropsArr
+    //  and (b) to determine whether the component should update itself (re-render)
+     * @param inComp The component whose properties are being obtained
+     */
+    getComponentProps(inComp = null) {
+        let compProps = {};
+        let addProps = {};
+        if (inComp === null) {
+            console.error(`AngularPConnect: getComponentProps called with bad component: ${inComp}`);
+        }
+        // if ((inComp.constructor.name === "FlowContainerComponent") || (inComp.constructor.name === "ViewContainerComponent")
+        //     || (inComp.constructor.name === "ViewComponent") || (inComp.constructor.name === "DeferLoadComponent")) {
+        //   console.log(`--> AngularPConnect getComponentProps: ${inComp.constructor.name}`);
+        // }
+        if (inComp.additionalProps !== undefined) {
+            if (typeof inComp.additionalProps === 'object') {
+                addProps = inComp.pConn$.resolveConfigProps(inComp.additionalProps);
+            }
+            else if (typeof inComp.additionalProps === 'function') {
+                const propsToAdd = inComp.additionalProps(PCore.getStore().getState(), inComp.pConn$);
+                addProps = inComp.pConn$.resolveConfigProps(propsToAdd);
+            }
+        }
+        compProps = inComp.pConn$.getConfigProps();
+        // const componentName = inComp.constructor.name;
+        // The following comment is from the Nebula/Constellation version of this code. Meant as a reminder to check this occasionally
+        // populate additional props which are component specific and not present in configurations
+        // This block can be removed once all these props will be added as part of configs
+        inComp.pConn$.populateAdditionalProps(compProps);
+        compProps = inComp.pConn$.resolveConfigProps(compProps);
+        if (compProps && undefined !== compProps.validatemessage && compProps.validatemessage != '') {
+            // console.log( `   validatemessage for ${inComp.constructor.name} ${inComp.angularPConnectData.compID}: ${compProps.validatemessage}`);
+        }
+        return {
+            ...compProps,
+            ...addProps
+        };
+    }
+    /**
+     * Returns the unique id for given component created when registering
+     * Otherwise, return undefined.
+     * @param inComp The component whose property is being requested.
+     */
+    getComponentID(inComp) {
+        return inComp.bridgeComponentID || inComp.angularPConnectData.compID;
+    }
+    /**
+     * Returns the value of requested property for the component if it exists.
+     * Otherwise, return undefined.
+     * @param inComp The component whose property is being requested.
+     * @param inProp The property being requested.
+     */
+    getComponentProp(inComp = null, inProp = '') {
+        if (inComp === null) {
+            console.error(`AngularPConnect: getComponentProp called with bad component: ${inComp}`);
+        }
+        const compID = inComp.angularPConnectData.compID;
+        // Look up property in the component's entry in componentPropArray (which should have the most recent value)
+        return this.componentPropsArr[compID][inProp];
+    }
+    /**
+     *
+     * @returns The current complete set of resolved properties that are associated with
+     * this component.
+     * This is the full set of properties that are tracked in Redux for this component.
+     */
+    getCurrentCompleteProps(inComp = null) {
+        if (inComp === null) {
+            console.error(`AngularPConnect: getCurrentCompleteProps called with bad component: ${inComp}`);
+        }
+        return this.componentPropsArr[inComp.angularPConnectData.compID];
+    }
+    /**
+     * Registers the component and its callback function. When a component calls this method
+     * (typically from its ngOnInit), the component is given a unique componentID (for this session)
+     * and subscribes the component to the store. As a side effect, it also assigns the component's
+     * actions (from its metadata) to the component's ___actions___ and binds the component's callback
+     * (passed in as ___inCallback___) to the component. If a problem is encountered, an empty object,
+     * {}, is returned.
+     * @param inComp The component being registered and subscribed
+     * @param inCallback The component's callback function (typically called onStateChange) that
+     * will be called whenever the state changes.
+     * @returns A JSON object with the following keys:
+     * compID: the unique ID associated with this component,
+     * unsubscribeFn: the function to be called when the component needs to unsubscribe from the store,
+     * validateMessage: any validation/error message that gets generated for this object,
+     * actions: any actions that are defined for this object
+     */
+    registerAndSubscribeComponent(inComp, inCallback = null) {
+        // Create an initial object to be returned.
+        const returnObject = {
+            compID: '',
+            unsubscribeFn: undefined,
+            validateMessage: '',
+            actions: undefined
+        };
+        if (inComp === null || inCallback === null) {
+            console.error(`AngularPConnect: bad call to registerAndSubscribe: inComp: ${inComp} inCallback: ${inCallback}`);
+            return returnObject;
+        }
+        const compType = inComp.constructor.name;
+        if (AngularPConnectService.bLogging) {
+            console.log(`registerAndSubscribeComponent: ${compType}`);
+        }
+        if (undefined !== inComp.bridgeComponentID) {
+            console.error(`OLD SCHOOL: ${compType}`);
+        }
+        if (undefined === inComp.actions && undefined === inComp.angularPConnectData) {
+            console.error(`AngularPConnect: bad call to registerAndSubscribe from ${compType}: actions not defined as a class variable for inComp`);
+            return returnObject;
+        }
+        if (undefined === inComp.bridgeComponentID && undefined === inComp.angularPConnectData) {
+            console.error(`AngularPConnect: bad call to registerAndSubscribe from ${compType}: bridgeComponentID not defined as a class variable for inComp`);
+            return returnObject;
+        }
+        if (undefined === inComp.unsubscribeStore && undefined === inComp.angularPConnectData) {
+            console.error(`AngularPConnect: bad call to registerAndSubscribe from ${compType}: unsubscribeStore not defined as a class variable for inComp`);
+            return returnObject;
+        }
+        if (undefined === inComp.validateMessage && undefined === inComp.angularPConnectData) {
+            console.error(`AngularPConnect: bad call to registerAndSubscribe from ${compType}: validateMessage not defined as a class variable for inComp`);
+            return returnObject;
+        }
+        // call processActions to populate metadata with actions as in PConnectHOR initialize
+        this.processActions(inComp);
+        if (undefined === inComp.actions) {
+            returnObject.actions = inComp.pConn$.getActions();
+        }
+        else {
+            inComp.actions = inComp.pConn$.getActions();
+        }
+        // bind the provided callback to the component it's associated with
+        inCallback = inCallback.bind(inComp);
+        // Now proceed to register and subscribe...
+        const theCompID = this.getNextComponentId();
+        const theUnsub = this.subscribeToStore(inComp, inCallback);
+        if (undefined === inComp.angularPConnectData) {
+            inComp.bridgeComponentID = theCompID;
+        }
+        else {
+            returnObject.compID = theCompID;
+            returnObject.unsubscribeFn = theUnsub;
+        }
+        // initialize this components entry in the componentPropsArr
+        this.componentPropsArr[theCompID] = {};
+        // return object with compID and unsubscribe...
+        return returnObject;
+    }
+    // Returns true if the component's entry in ___componentPropsArr___ is
+    //  the same as the inCompProps passed in.
+    //  As a side effect, update the component's entry in componentPropsArr
+    //  NOTE: It is assumed that the incoming component has the following:
+    //  * a bridgeComponentID <string> property - used as lookup key in componentPropsArr
+    //  * a pConn$ <?> property - used to access functions accessed in getComponentProps
+    // Return true: means the component props are different and the component should update itself (re-render)
+    // Return false: means the component props are the same and the component doesn't need to update (re-render)
+    //  On bad input, return false;
+    /**
+     * Returns **true** if the component's entry in ___componentPropsArr___ is
+     * the same as the properties that are current associated with the component (___inComp___) passed in.
+     * As a side effect, the component's entry in ___componentPropsArr___ is updated.
+     * **Note**: It is assumed that the incoming component has the following:
+     * (a) a bridgeComponentID _string_ property used as lookup key in ___componentPropsArr___
+     * and (b) a ___pConn$___ property used to access functions called in ___getComponentProps___
+     *
+     * @param inComp The component asking if it should update itself
+     * @returns Return **true**: means the component props are different and the component should update itself (re-render).
+     * Return **false**: means the component props are the same and the component doesn't need to update (re-render).
+     * If the ***inComp*** input is bad, false is also returned.
+     */
+    shouldComponentUpdate(inComp) {
+        // const bShowLogging = false;
+        let bRet = false;
+        // check for reasonable input
+        if (Utils.isEmptyObject(inComp)) {
+            console.error(`AngularPConnect: bad call to shouldComponentUpdate: inComp: ${JSON.stringify(inComp)}`);
+            return bRet;
+        }
+        if (undefined === inComp.validateMessage && undefined === inComp.angularPConnectData) {
+            console.error(`AngularPConnect: bad call to shouldComponentUpdate: ${inComp.constructor.name} does not have a validateMessage property.`);
+        }
+        const compID = this.getComponentID(inComp);
+        const currentProps = this.componentPropsArr[compID];
+        const currentPropsAsStr = JSON.stringify(currentProps);
+        const incomingProps = this.getComponentProps(inComp);
+        // if have pageMessages, and it is blank, remove it.  This causes issues of making it appear
+        // that a will cause an update, when there is no change
+        if (this.isPageMessagesEmpty(incomingProps)) {
+            inComp.angularPConnectData.pageMessages = incomingProps.pageMessages;
+            delete incomingProps.pageMessages;
+        }
+        if (incomingProps.httpMessages) {
+            inComp.angularPConnectData.httpMessages = incomingProps.httpMessages;
+            incomingProps.httpMessages = undefined;
+        }
+        const incomingPropsAsStr = JSON.stringify(incomingProps);
+        bRet = isEqual ? !isEqual(currentProps, incomingProps) : currentPropsAsStr != incomingPropsAsStr;
+        // Below piece of code is needed to re-render the component since we wanna evaluate the Visibility expression within View component in such cases
+        if (inComp.pConn$.meta.config.context?.length > 0 && inComp.pConn$.getPageReference().length > 'caseInfo.content'.length) {
+            return true;
+        }
+        // Now update the entry in componentPropsArr with the incoming value so
+        //  we can compare against that next time...
+        this.componentPropsArr[compID] = incomingProps;
+        const validatemessage = incomingProps.validatemessage === undefined ? '' : this.utils.htmlDecode(incomingProps.validatemessage);
+        // and update the component's validation message (if undefined, it should be set to "")
+        if (undefined !== inComp.angularPConnectData) {
+            inComp.angularPConnectData.validateMessage = validatemessage;
+            if (inComp.angularPConnectData.validateMessage != '') {
+                // if have a validate message, turn off spinner
+                const timer = interval(100).subscribe(() => {
+                    this.psService.sendMessage(false);
+                    timer.unsubscribe();
+                });
+                let sErrorMessage = currentProps && currentProps.label ? currentProps.label.concat(' - ') : '';
+                sErrorMessage = sErrorMessage.concat(inComp.angularPConnectData.validateMessage);
+                this.erService.sendMessage('update', sErrorMessage);
+            }
+        }
+        else {
+            inComp.validateMessage = validatemessage;
+        }
+        if (bRet && compID === undefined) {
+            bRet = false;
+        }
+        // console.log( `AngularPConnect component ${compID} - ${inComp.constructor.name} - shouldComponentUpdate: ${bRet}`);
+        // console.log("current props: " + currentPropsAsStr);
+        if (bRet) {
+            // console.log(`**** change for: ${inComp.constructor.name}`);
+            // console.log("current props: " + currentPropsAsStr);
+            // console.log("incoming props: " + incomingPropsAsStr);
+            // console.log(`    ${inComp.constructor.name}: shouldComponentUpdate returning: ${bRet}, compId: ${compID}` );
+            // console.log( `    Updating with componentProps for ${inComp.constructor.name}: ${JSON.stringify(this.componentPropsArr[compID])}`);
+            // console.log( `          and validateMessage: ${inComp.validateMessage}`);
+        }
+        // else if (inComp.constructor.name.indexOf("View") >= 0 || inComp.constructor.name.indexOf("Root") >= 0) {
+        //   console.log("no change");
+        //   console.log("current props: " + currentPropsAsStr);
+        //   console.log("incoming props: " + incomingPropsAsStr);
+        //   console.log(`    ${inComp.constructor.name}: shouldComponentUpdate returning: ${bRet}, compId: ${compID}` );
+        // }
+        // console.log(`    ${inComp.constructor.name}: shouldComponentUpdate returning: ${bRet}`);
+        return bRet;
+    }
+    isPageMessagesEmpty(incomingProps) {
+        return incomingProps.pageMessages && incomingProps.pageMessages.length === 0;
+    }
+    /**
+     * Can be called when the component has encountered a change event
+     * @param inComp The component calling the change event
+     * @param event The event
+     */
+    changeHandler(inComp, event) {
+        const bLogging = false;
+        if (bLogging) {
+            // console.log(`AngularPConnect.changeHandler`);
+        }
+        // check for reasonable input
+        if (undefined === inComp || Utils.isEmptyObject(inComp)) {
+            console.error(`AngularPConnect: bad call to changeHandler: inComp: ${JSON.stringify(inComp)}`);
+            return;
+        }
+        const pConnect = inComp.pConn$;
+        if (undefined === pConnect) {
+            console.error(`AngularPConnect: bad call to changeHandler: inComp.pConn$: ${pConnect}`);
+            return;
+        }
+        // clear out errors
+        this.erService.sendMessage('dismiss', '');
+        pConnect.getActionsApi().changeHandler(pConnect, event);
+    }
+    /**
+     * Can be called when the component has encountered an event (such as blur)
+     * @param inComp The component calling the event
+     * @param event The event
+     */
+    eventHandler(inComp, event) {
+        const bLogging = false;
+        if (bLogging) {
+            // console.log(`AngularPConnect.eventHandler`);
+        }
+        // check for reasonable input
+        if (undefined === inComp || Utils.isEmptyObject(inComp)) {
+            console.error(`AngularPConnect: bad call to eventHandler: inComp: ${JSON.stringify(inComp)}`);
+            return;
+        }
+        const pConnect = inComp.pConn$;
+        if (undefined === pConnect) {
+            console.error(`AngularPConnect: bad call to eventHandler: inComp.pConn$: ${pConnect}`);
+            return;
+        }
+        pConnect.getActionsApi().eventHandler(pConnect, event);
+    }
+    /**
+     * @returns A handle to the application's store
+     */
+    getStore() {
+        if (this.theStore === null) {
+            this.theStore = PCore.getStore();
+        }
+        return this.theStore;
+    }
+    /**
+     * @param bLogMsg If true, will write the stringified state to the store for debugging/inspection
+     * @param inComp If supplied, the component that is requesting the store's state
+     * @returns A handle to the __state__ of application's store
+     */
+    getState(bLogMsg = false, inComp = null) {
+        const theState = this.getStore().getState();
+        if (bLogMsg) {
+            const theCompName = inComp ? `${inComp.constructor.name}: ` : '';
+            console.log(`${theCompName} Store state: ${JSON.stringify(theState)}`);
+        }
+        return theState;
+    }
+    // processActions - carried over from PConnectHOC initialize
+    /**
+     *  processActions exposes all actions in the metadata.
+     *  Attaches common handler (eventHandler) for all actions.
+     */
+    processActions(inComp) {
+        const pConnect = inComp.pConn$;
+        if (undefined === pConnect) {
+            console.error(`AngularPConnect: bad call to processActions: pConn$: ${pConnect} from component: ${inComp.constructor.name}`);
+            return;
+        }
+        if (inComp.pConn$.isEditable()) {
+            inComp.pConn$.setAction('onChange', this.changeHandler.bind(this));
+            inComp.pConn$.setAction('onBlur', this.eventHandler.bind(this));
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AngularPConnectService, deps: [{ token: i1.ProgressSpinnerService }, { token: i2.ErrorMessagesService }, { token: i3.Utils }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AngularPConnectService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AngularPConnectService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ProgressSpinnerService }, { type: i2.ErrorMessagesService }, { type: i3.Utils }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"angular-pconnect.js","sourceRoot":"","sources":["../../../../../packages/angular-sdk-components/src/lib/_bridge/angular-pconnect.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { interval } from 'rxjs';\nimport isEqual from 'fast-deep-equal';\nimport { ProgressSpinnerService } from '../_messages/progress-spinner.service';\nimport { ErrorMessagesService } from '../_messages/error-messages.service';\nimport { Utils } from '../_helpers/utils';\n\nexport interface AngularPConnectData {\n  compID?: string;\n  unsubscribeFn?: Function;\n  validateMessage?: string;\n  actions?: {\n    onChange: Function;\n    onBlur: Function;\n  };\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class AngularPConnectService {\n  /**\n   * Local variable for access to the store once the service is connected to it.\n   */\n  private theStore: any = null;\n\n  /**\n   * Local variable used to compute the next componentID\n   */\n  private counterComponentID = 0;\n\n  /**\n   * Local array used to store the association of an component to its most recent \"props\"\n   *  where \"props\" is the object containing the component's getConfigProps along with\n   * anything added by populateAdditionalProps.\n   * Each entry is: { __componentID__: _the component's most recent props_ }\n   */\n  private componentPropsArr: Object[] = [];\n\n  /* Used to toggle some class-wide logging */\n  private static bLogging = false;\n\n  constructor(\n    private psService: ProgressSpinnerService,\n    private erService: ErrorMessagesService,\n    private utils: Utils\n  ) {\n    // Establish necessary override flags for our use of Core\n    // const coreOverrides = { \"dynamicLoadComponents\": false };\n    // let coreOverrides = PCore.getBehaviorOverrides();\n    // coreOverrides[\"dynamicLoadComponents\"] = false;\n    // PCore.setBehaviorOverrides( coreOverrides );\n    PCore.setBehaviorOverride('dynamicLoadComponents', false);\n\n    // Always best to use deep object compare when it's available\n    // if (isEqual !== undefined) {\n    // console.log(`AngularPConnect is using deep object compare`);\n    // } else {\n    // console.log(`AngularPConnect is using JSON.stringify compare`);\n    // }\n  }\n\n  /**\n   * Returns a unique (for this session) ComponentID that should\n   * be used for that component to update its most recent props\n   * (which can also be compared against its previous value\n   * before updating). Note that this returns a string so we can use\n   * it as a key in an associative array\n   * @returns the next componentID\n   */\n  private getNextComponentId(): string {\n    this.counterComponentID += 1;\n    // Note that we use the string version of the number so we have an\n    //  associative array that we can clean up later, if needed.\n    return this.counterComponentID.toString();\n  }\n\n  /**\n   * The Calling object (inComp) subscribes to store changes.\n   * @param inComp The component that's subscribing to the store\n   * @param inCallback The component's callback function (typically called onStateChange) that will\n   * be called when the store changes.\n   * @returns The **unsubscribe** function that should be called when the component needs\n   * to unsubscribe from the store. (Typically during ngOnDestroy)\n   */\n  private subscribeToStore(inComp: any = null, inCallback: Function | null = null): Function {\n    // const theCompName: string = inComp ? `${inComp.constructor.name}` : 'no component provided';\n    let fnUnsubscribe;\n    // console.log( `Bridge subscribing: ${theCompName} `);\n    if (inComp) {\n      fnUnsubscribe = this.getStore().subscribe(inCallback);\n    }\n    return fnUnsubscribe;\n  }\n\n  /**\n   * Gets the Component's properties that are used (a) to populate componentPropsArr\n  //  and (b) to determine whether the component should update itself (re-render)\n   * @param inComp The component whose properties are being obtained\n   */\n  private getComponentProps(inComp: any = null): Object {\n    let compProps: any = {};\n    let addProps = {};\n\n    if (inComp === null) {\n      console.error(`AngularPConnect: getComponentProps called with bad component: ${inComp}`);\n    }\n\n    // if ((inComp.constructor.name === \"FlowContainerComponent\") || (inComp.constructor.name === \"ViewContainerComponent\")\n    //     || (inComp.constructor.name === \"ViewComponent\") || (inComp.constructor.name === \"DeferLoadComponent\")) {\n    //   console.log(`--> AngularPConnect getComponentProps: ${inComp.constructor.name}`);\n    // }\n\n    if (inComp.additionalProps !== undefined) {\n      if (typeof inComp.additionalProps === 'object') {\n        addProps = inComp.pConn$.resolveConfigProps(inComp.additionalProps);\n      } else if (typeof inComp.additionalProps === 'function') {\n        const propsToAdd = inComp.additionalProps(PCore.getStore().getState(), inComp.pConn$);\n        addProps = inComp.pConn$.resolveConfigProps(propsToAdd);\n      }\n    }\n\n    compProps = inComp.pConn$.getConfigProps();\n\n    // const componentName = inComp.constructor.name;\n\n    // The following comment is from the Nebula/Constellation version of this code. Meant as a reminder to check this occasionally\n    // populate additional props which are component specific and not present in configurations\n    // This block can be removed once all these props will be added as part of configs\n    inComp.pConn$.populateAdditionalProps(compProps);\n\n    compProps = inComp.pConn$.resolveConfigProps(compProps);\n\n    if (compProps && undefined !== compProps.validatemessage && compProps.validatemessage != '') {\n      // console.log( `   validatemessage for ${inComp.constructor.name} ${inComp.angularPConnectData.compID}: ${compProps.validatemessage}`);\n    }\n\n    return {\n      ...compProps,\n      ...addProps\n    };\n  }\n\n  /**\n   * Returns the unique id for given component created when registering\n   * Otherwise, return undefined.\n   * @param inComp The component whose property is being requested.\n   */\n  public getComponentID(inComp): string {\n    return inComp.bridgeComponentID || inComp.angularPConnectData.compID;\n  }\n\n  /**\n   * Returns the value of requested property for the component if it exists.\n   * Otherwise, return undefined.\n   * @param inComp The component whose property is being requested.\n   * @param inProp The property being requested.\n   */\n  public getComponentProp(inComp: any = null, inProp = '') {\n    if (inComp === null) {\n      console.error(`AngularPConnect: getComponentProp called with bad component: ${inComp}`);\n    }\n\n    const compID = inComp.angularPConnectData.compID;\n\n    // Look up property in the component's entry in componentPropArray (which should have the most recent value)\n    return this.componentPropsArr[compID][inProp];\n  }\n\n  /**\n   *\n   * @returns The current complete set of resolved properties that are associated with\n   * this component.\n   * This is the full set of properties that are tracked in Redux for this component.\n   */\n  public getCurrentCompleteProps(inComp: any = null) {\n    if (inComp === null) {\n      console.error(`AngularPConnect: getCurrentCompleteProps called with bad component: ${inComp}`);\n    }\n    return this.componentPropsArr[inComp.angularPConnectData.compID];\n  }\n\n  /**\n   * Registers the component and its callback function. When a component calls this method\n   * (typically from its ngOnInit), the component is given a unique componentID (for this session)\n   * and subscribes the component to the store. As a side effect, it also assigns the component's\n   * actions (from its metadata) to the component's ___actions___ and binds the component's callback\n   * (passed in as ___inCallback___) to the component. If a problem is encountered, an empty object,\n   * {}, is returned.\n   * @param inComp The component being registered and subscribed\n   * @param inCallback The component's callback function (typically called onStateChange) that\n   * will be called whenever the state changes.\n   * @returns A JSON object with the following keys:\n   * compID: the unique ID associated with this component,\n   * unsubscribeFn: the function to be called when the component needs to unsubscribe from the store,\n   * validateMessage: any validation/error message that gets generated for this object,\n   * actions: any actions that are defined for this object\n   */\n  registerAndSubscribeComponent(inComp, inCallback: Function | null = null): AngularPConnectData {\n    // Create an initial object to be returned.\n    const returnObject: AngularPConnectData = {\n      compID: '',\n      unsubscribeFn: undefined,\n      validateMessage: '',\n      actions: undefined\n    };\n\n    if (inComp === null || inCallback === null) {\n      console.error(`AngularPConnect: bad call to registerAndSubscribe: inComp: ${inComp} inCallback: ${inCallback}`);\n      return returnObject;\n    }\n\n    const compType = inComp.constructor.name;\n\n    if (AngularPConnectService.bLogging) {\n      console.log(`registerAndSubscribeComponent: ${compType}`);\n    }\n\n    if (undefined !== inComp.bridgeComponentID) {\n      console.error(`OLD SCHOOL: ${compType}`);\n    }\n\n    if (undefined === inComp.actions && undefined === inComp.angularPConnectData) {\n      console.error(`AngularPConnect: bad call to registerAndSubscribe from ${compType}: actions not defined as a class variable for inComp`);\n      return returnObject;\n    }\n    if (undefined === inComp.bridgeComponentID && undefined === inComp.angularPConnectData) {\n      console.error(\n        `AngularPConnect: bad call to registerAndSubscribe from ${compType}: bridgeComponentID not defined as a class variable for inComp`\n      );\n      return returnObject;\n    }\n    if (undefined === inComp.unsubscribeStore && undefined === inComp.angularPConnectData) {\n      console.error(\n        `AngularPConnect: bad call to registerAndSubscribe from ${compType}: unsubscribeStore not defined as a class variable for inComp`\n      );\n      return returnObject;\n    }\n    if (undefined === inComp.validateMessage && undefined === inComp.angularPConnectData) {\n      console.error(`AngularPConnect: bad call to registerAndSubscribe from ${compType}: validateMessage not defined as a class variable for inComp`);\n      return returnObject;\n    }\n\n    // call processActions to populate metadata with actions as in PConnectHOR initialize\n    this.processActions(inComp);\n    if (undefined === inComp.actions) {\n      returnObject.actions = inComp.pConn$.getActions();\n    } else {\n      inComp.actions = inComp.pConn$.getActions();\n    }\n\n    // bind the provided callback to the component it's associated with\n    inCallback = inCallback.bind(inComp);\n\n    // Now proceed to register and subscribe...\n    const theCompID: string = this.getNextComponentId();\n    const theUnsub: Function | null = this.subscribeToStore(inComp, inCallback);\n\n    if (undefined === inComp.angularPConnectData) {\n      inComp.bridgeComponentID = theCompID;\n    } else {\n      returnObject.compID = theCompID;\n      returnObject.unsubscribeFn = theUnsub;\n    }\n\n    // initialize this components entry in the componentPropsArr\n    this.componentPropsArr[theCompID] = {};\n\n    // return object with compID and unsubscribe...\n    return returnObject;\n  }\n\n  // Returns true if the component's entry in ___componentPropsArr___ is\n  //  the same as the inCompProps passed in.\n  //  As a side effect, update the component's entry in componentPropsArr\n  //  NOTE: It is assumed that the incoming component has the following:\n  //  * a bridgeComponentID <string> property - used as lookup key in componentPropsArr\n  //  * a pConn$ <?> property - used to access functions accessed in getComponentProps\n  // Return true: means the component props are different and the component should update itself (re-render)\n  // Return false: means the component props are the same and the component doesn't need to update (re-render)\n  //  On bad input, return false;\n  /**\n   * Returns **true** if the component's entry in ___componentPropsArr___ is\n   * the same as the properties that are current associated with the component (___inComp___) passed in.\n   * As a side effect, the component's entry in ___componentPropsArr___ is updated.\n   * **Note**: It is assumed that the incoming component has the following:\n   * (a) a bridgeComponentID _string_ property used as lookup key in ___componentPropsArr___\n   * and (b) a ___pConn$___ property used to access functions called in ___getComponentProps___\n   *\n   * @param inComp The component asking if it should update itself\n   * @returns Return **true**: means the component props are different and the component should update itself (re-render).\n   * Return **false**: means the component props are the same and the component doesn't need to update (re-render).\n   * If the ***inComp*** input is bad, false is also returned.\n   */\n  shouldComponentUpdate(inComp): boolean {\n    // const bShowLogging = false;\n    let bRet = false;\n    // check for reasonable input\n    if (Utils.isEmptyObject(inComp)) {\n      console.error(`AngularPConnect: bad call to shouldComponentUpdate: inComp: ${JSON.stringify(inComp)}`);\n      return bRet;\n    }\n    if (undefined === inComp.validateMessage && undefined === inComp.angularPConnectData) {\n      console.error(`AngularPConnect: bad call to shouldComponentUpdate: ${inComp.constructor.name} does not have a validateMessage property.`);\n    }\n\n    const compID = this.getComponentID(inComp);\n\n    const currentProps: any = this.componentPropsArr[compID];\n    const currentPropsAsStr: string = JSON.stringify(currentProps);\n\n    const incomingProps: any = this.getComponentProps(inComp);\n\n    // if have pageMessages, and it is blank, remove it.  This causes issues of making it appear\n    // that a will cause an update, when there is no change\n    if (this.isPageMessagesEmpty(incomingProps)) {\n      inComp.angularPConnectData.pageMessages = incomingProps.pageMessages;\n      delete incomingProps.pageMessages;\n    }\n\n    if (incomingProps.httpMessages) {\n      inComp.angularPConnectData.httpMessages = incomingProps.httpMessages;\n      incomingProps.httpMessages = undefined;\n    }\n\n    const incomingPropsAsStr: string = JSON.stringify(incomingProps);\n\n    bRet = isEqual ? !isEqual(currentProps, incomingProps) : currentPropsAsStr != incomingPropsAsStr;\n\n    // Below piece of code is needed to re-render the component since we wanna evaluate the Visibility expression within View component in such cases\n    if (inComp.pConn$.meta.config.context?.length > 0 && inComp.pConn$.getPageReference().length > 'caseInfo.content'.length) {\n      return true;\n    }\n\n    // Now update the entry in componentPropsArr with the incoming value so\n    //  we can compare against that next time...\n    this.componentPropsArr[compID] = incomingProps;\n    const validatemessage = incomingProps.validatemessage === undefined ? '' : this.utils.htmlDecode(incomingProps.validatemessage);\n    // and update the component's validation message (if undefined, it should be set to \"\")\n    if (undefined !== inComp.angularPConnectData) {\n      inComp.angularPConnectData.validateMessage = validatemessage;\n\n      if (inComp.angularPConnectData.validateMessage != '') {\n        // if have a validate message, turn off spinner\n        const timer = interval(100).subscribe(() => {\n          this.psService.sendMessage(false);\n\n          timer.unsubscribe();\n        });\n\n        let sErrorMessage = currentProps && currentProps.label ? currentProps.label.concat(' - ') : '';\n        sErrorMessage = sErrorMessage.concat(inComp.angularPConnectData.validateMessage);\n        this.erService.sendMessage('update', sErrorMessage);\n      }\n    } else {\n      inComp.validateMessage = validatemessage;\n    }\n\n    if (bRet && compID === undefined) {\n      bRet = false;\n    }\n\n    // console.log( `AngularPConnect component ${compID} - ${inComp.constructor.name} - shouldComponentUpdate: ${bRet}`);\n    // console.log(\"current props: \" + currentPropsAsStr);\n\n    if (bRet) {\n      // console.log(`**** change for: ${inComp.constructor.name}`);\n      // console.log(\"current props: \" + currentPropsAsStr);\n      // console.log(\"incoming props: \" + incomingPropsAsStr);\n      // console.log(`    ${inComp.constructor.name}: shouldComponentUpdate returning: ${bRet}, compId: ${compID}` );\n      // console.log( `    Updating with componentProps for ${inComp.constructor.name}: ${JSON.stringify(this.componentPropsArr[compID])}`);\n      // console.log( `          and validateMessage: ${inComp.validateMessage}`);\n    }\n    // else if (inComp.constructor.name.indexOf(\"View\") >= 0 || inComp.constructor.name.indexOf(\"Root\") >= 0) {\n    //   console.log(\"no change\");\n    //   console.log(\"current props: \" + currentPropsAsStr);\n    //   console.log(\"incoming props: \" + incomingPropsAsStr);\n    //   console.log(`    ${inComp.constructor.name}: shouldComponentUpdate returning: ${bRet}, compId: ${compID}` );\n\n    // }\n\n    // console.log(`    ${inComp.constructor.name}: shouldComponentUpdate returning: ${bRet}`);\n\n    return bRet;\n  }\n\n  isPageMessagesEmpty(incomingProps) {\n    return incomingProps.pageMessages && incomingProps.pageMessages.length === 0;\n  }\n\n  /**\n   * Can be called when the component has encountered a change event\n   * @param inComp The component calling the change event\n   * @param event The event\n   */\n  changeHandler(inComp, event) {\n    const bLogging = false;\n    if (bLogging) {\n      // console.log(`AngularPConnect.changeHandler`);\n    }\n    // check for reasonable input\n    if (undefined === inComp || Utils.isEmptyObject(inComp)) {\n      console.error(`AngularPConnect: bad call to changeHandler: inComp: ${JSON.stringify(inComp)}`);\n      return;\n    }\n\n    const pConnect = inComp.pConn$;\n    if (undefined === pConnect) {\n      console.error(`AngularPConnect: bad call to changeHandler: inComp.pConn$: ${pConnect}`);\n      return;\n    }\n\n    // clear out errors\n    this.erService.sendMessage('dismiss', '');\n\n    pConnect.getActionsApi().changeHandler(pConnect, event);\n  }\n\n  /**\n   * Can be called when the component has encountered an event (such as blur)\n   * @param inComp The component calling the event\n   * @param event The event\n   */\n  eventHandler(inComp, event) {\n    const bLogging = false;\n    if (bLogging) {\n      // console.log(`AngularPConnect.eventHandler`);\n    }\n    // check for reasonable input\n    if (undefined === inComp || Utils.isEmptyObject(inComp)) {\n      console.error(`AngularPConnect: bad call to eventHandler: inComp: ${JSON.stringify(inComp)}`);\n      return;\n    }\n\n    const pConnect = inComp.pConn$;\n    if (undefined === pConnect) {\n      console.error(`AngularPConnect: bad call to eventHandler: inComp.pConn$: ${pConnect}`);\n      return;\n    }\n\n    pConnect.getActionsApi().eventHandler(pConnect, event);\n  }\n\n  /**\n   * @returns A handle to the application's store\n   */\n  getStore() {\n    if (this.theStore === null) {\n      this.theStore = PCore.getStore();\n    }\n    return this.theStore;\n  }\n\n  /**\n   * @param bLogMsg If true, will write the stringified state to the store for debugging/inspection\n   * @param inComp If supplied, the component that is requesting the store's state\n   * @returns A handle to the __state__ of application's store\n   */\n  getState(bLogMsg: boolean = false, inComp: any = null) {\n    const theState: object = this.getStore().getState();\n    if (bLogMsg) {\n      const theCompName: string = inComp ? `${inComp.constructor.name}: ` : '';\n      console.log(`${theCompName} Store state: ${JSON.stringify(theState)}`);\n    }\n    return theState;\n  }\n\n  // processActions - carried over from PConnectHOC initialize\n  /**\n   *  processActions exposes all actions in the metadata.\n   *  Attaches common handler (eventHandler) for all actions.\n   */\n  private processActions(inComp) {\n    const pConnect = inComp.pConn$;\n    if (undefined === pConnect) {\n      console.error(`AngularPConnect: bad call to processActions: pConn$: ${pConnect} from component: ${inComp.constructor.name}`);\n      return;\n    }\n\n    if (inComp.pConn$.isEditable()) {\n      inComp.pConn$.setAction('onChange', this.changeHandler.bind(this));\n      inComp.pConn$.setAction('onBlur', this.eventHandler.bind(this));\n    }\n  }\n}\n"]}