jsf.js_next_gen 1.0.0-beta-16 → 1.0.0-beta-18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsf.js_next_gen",
-  "version": "1.0.0-beta-16",
+  "version": "1.0.0-beta-18",
   "description": "A next generation typescript reimplementation of jsf.js",
   "main": "dist/window/jsf.js",
   "scripts": {
@@ -48,6 +48,6 @@
     "webpack-dev-server": "^4.11.1"
   },
   "dependencies": {
-    "mona-dish": "0.21.16"
+    "mona-dish": "0.21.17"
   }
 }

package/src/main/typescript/impl/AjaxImpl.ts

@@ -95,6 +95,54 @@ enum BlockFilter {
  * however a dedicated api makes sense for readability reasons
  */
 export module Implementation {
+/*
+ Small internal explanation, this code is optimized for readability
+ and cuts off a ton of old legacy code.
+ Aka older browsers are not supported anymore.
+ We use a self written helper library to keep the number of exernal
+ code dependencies down.
+ The library is called mona-dish and started as a small sideproject of mine
+ it provides following
+
+ a) Monad like structures for querying because this keeps the code denser and adds abstractions
+ that always was the strong point of jquery and it still is better in this regard than what ecmascript provides
+
+ b) Streams and lazystreams like java has, a pull like construct, ecmascript does not have anything like Lazystreams.
+ Another option would have been rxjs but that would have introduced a code dependency and probably more code. We might
+ move to RXJS if the need arises however. But for now I would rather stick with my small self grown library which works
+ quite well and where I can patch quickly (I have used it in several industrial projects, so it works well
+ and is heavily fortified by unit tests (140 testcases as time of writing this))
+
+ c) A neutral json like configuration which allows assignments of arbitrary values with reduce code which then can be
+ transformed into different data representations
+
+ examples:
+ internalCtx.assign(MYPARAM, CTX_PARAM_SRC_FRM_ID).value = form.id.value;
+ passes a value into context.MYPARAM.CTX_PARAM_SRC_FRM_ID
+
+ basically an abbreviation for
+
+ internalCtxt[MYPARAM] = internalCtxt?.[MYPARAM] ?  internalCtxt[MYPARAM] : {};
+ internalCtxt[MYPARAM][CTX_PARAM_SRC_FRM_ID] = internalCtxt?.[MYPARAM][CTX_PARAM_SRC_FRM_ID] ?  internalCtxt[MYPARAM][CTX_PARAM_SRC_FRM_ID] : {};
+ internalCtxt[MYPARAM][CTX_PARAM_SRC_FRM_ID] = form.id.value;
+
+
+ internalCtx.assign(condition, MYPARAM, CTX_PARAM_SRC_FRM_ID).value = form.id.value;
+ passes a value into context.MYPARAM.CTX_PARAM_SRC_FRM_ID if condition === true otherwise it is ignored
+
+ abbreviates:
+ if(condition) {
+    internalCtxt[MYPARAM] = internalCtxt?.[MYPARAM] ?  internalCtxt[MYPARAM] : {};
+    internalCtxt[MYPARAM][CTX_PARAM_SRC_FRM_ID] = internalCtxt?.[MYPARAM][CTX_PARAM_SRC_FRM_ID] ?  internalCtxt[MYPARAM][CTX_PARAM_SRC_FRM_ID] : {};
+    internalCtxt[MYPARAM][CTX_PARAM_SRC_FRM_ID] = form.id.value;
+ }
+
+
+ d) Optional constructs, while under heavy debate we only use them lightly where the api requires it from mona-dish
+
+ Note the inclusion of this library uses a reduced build which only includes the part of it, which we really use
+
+ */
 
     import trim = Lang.trim;
     import getMessage = ExtLang.getMessage;
@@ -170,8 +218,9 @@ export module Implementation {
 
         return LazyStream.of(...funcs)
             .map(func => resolveAndExecute(source, event, func))
-            // we use the return false == stop as an early stop
+            // we use the return false == stop as an early stop, onElem stops at the first false
             .onElem((opResult: boolean) => opResult)
+            //last ensures we run until the first false is returned
             .last().value;
     }
 
@@ -208,17 +257,27 @@ export module Implementation {
 
         Assertions.assertRequestIntegrity(options, elem);
 
-        requestCtx.assignIf(!!windowId, P_WINDOW_ID).value = windowId;
+        /**
+         * fetch the parent form
+         *
+         * note we also add an override possibility here
+         * so that people can use dummy forms and work
+         * with detached objects
+         */
+        const form: DQ = resolveForm(requestCtx, elem, resolvedEvent);
+        const formId = form.id.value;
+        const delay: number = resolveDelay(options);
+        const timeout: number = resolveTimeout(options);
 
+        requestCtx.assignIf(!!windowId, P_WINDOW_ID).value = windowId;
         requestCtx.assign(CTX_PARAM_PASS_THR).value = filterPassthroughValues(options.value);
-
         requestCtx.assignIf(!!resolvedEvent, CTX_PARAM_PASS_THR, P_EVT).value = resolvedEvent?.type;
 
         /**
          * ajax pass through context with the source
-         * onresolvedEvent and onerror
+         * onresolved Event and onerror Event
          */
-        requestCtx.assign(SOURCE).value = elementId.value;
+        requestCtx.assign(SOURCE).value = elementId;
 
         /**
          * on resolvedEvent and onError...
@@ -232,30 +291,17 @@ export module Implementation {
          * lets drag the myfaces config params also in
          */
         requestCtx.assign(MYFACES).value = options.value?.myfaces;
-        /**
-         * fetch the parent form
-         *
-         * note we also add an override possibility here
-         * so that people can use dummy forms and work
-         * with detached objects
-         */
-        let form: DQ = resolveForm(requestCtx, elem, resolvedEvent);
 
         /**
          * binding contract the javax.faces.source must be set
          */
-        requestCtx.assign(CTX_PARAM_PASS_THR, P_PARTIAL_SOURCE).value = elementId.value;
+        requestCtx.assign(CTX_PARAM_PASS_THR, P_PARTIAL_SOURCE).value = elementId;
 
         /**
          * javax.faces.partial.ajax must be set to true
          */
         requestCtx.assign(CTX_PARAM_PASS_THR, P_AJAX).value = true;
 
-        /**
-         * binding contract the javax.faces.source must be set
-         */
-        requestCtx.assign(CTX_PARAM_PASS_THR, P_PARTIAL_SOURCE).value = elementId.value;
-
         /**
          * if resetValues is set to true
          * then we have to set javax.faces.resetValues as well
@@ -265,27 +311,22 @@ export module Implementation {
          */
         requestCtx.assignIf(isResetValues, CTX_PARAM_PASS_THR, P_RESET_VALUES).value = true;
 
-        //additional meta information to speed things up, note internal non jsf
-        //pass through options are stored under _mfInternal in the context
-        internalCtx.assign(CTX_PARAM_SRC_FRM_ID).value = form.id.value;
-        internalCtx.assign(CTX_PARAM_SRC_CTL_ID).value = elementId.value;
+        // additional meta information to speed things up, note internal non jsf
+        // pass through options are stored under _mfInternal in the context
+        internalCtx.assign(CTX_PARAM_SRC_FRM_ID).value = formId;
+
+        // mojarra compatibility, mojarra is sending the form id as well
+        // this is not documented behavior but can be determined by running
+        // mojarra under blackbox conditions.
+        // I assume it does the same as our formId_submit=1 so leaving it out
+        // won't hurt but for the sake of compatibility we are going to add it
+        requestCtx.assign(CTX_PARAM_PASS_THR, formId).value = formId;
+        internalCtx.assign(CTX_PARAM_SRC_CTL_ID).value = elementId;
         internalCtx.assign(CTX_PARAM_TR_TYPE).value = REQ_TYPE_POST;
 
-        //mojarra compatibility, mojarra is sending the form id as well
-        //this is not documented behavior but can be determined by running
-        //mojarra under blackbox conditions
-        //i assume it does the same as our formId_submit=1 so leaving it out
-        //wont hurt but for the sake of compatibility we are going to add it
-
-        requestCtx.assign(CTX_PARAM_PASS_THR, form.id.value).value = form.id.value;
-
         assignClientWindowId(form, requestCtx);
-
-        assignExecute(options, requestCtx, form, elementId.value);
-        assignRender(options, requestCtx, form, elementId.value);
-
-        let delay: number = resolveDelay(options);
-        let timeout: number = resolveTimeout(options);
+        assignExecute(options, requestCtx, form, elementId);
+        assignRender(options, requestCtx, form, elementId);
 
         //now we enqueue the request as asynchronous runnable into our request
         //queue and let the queue take over the rest
@@ -308,7 +349,6 @@ export module Implementation {
      * @param errorListener the error listener handler
      */
     export function addOnError(errorListener: IListener<ErrorData>) {
-        /*error handling already done in the assert of the queue*/
         errorQueue.push(errorListener);
     }
 
@@ -318,7 +358,6 @@ export module Implementation {
      * @param eventListener the event listener handler
      */
     export function addOnEvent(eventListener: IListener<EventData>) {
-        /*error handling already done in the assert of the queue*/
         eventQueue.push(eventListener);
     }
 
@@ -480,7 +519,7 @@ export module Implementation {
 
     /**
      * this at the first sight looks like a weird construct, but we need to do it this way
-     * for testing, we cannot proxy addRequestToQueue from the testing frameworks directly
+     * for testing, we cannot proxy addRequestToQueue from the testing frameworks directly,
      * but we need to keep it under unit tests.
      */
     export let queueHandler = {
@@ -572,15 +611,12 @@ export module Implementation {
     function remapDefaultConstants(targetConfig: Config, targetKey: string, userValues: string, issuingForm: DQ, issuingElementId: string): Config {
         //a cleaner implementation of the transform list method
 
-        let iterValues = (userValues) ? trim(userValues).split(/\s+/gi) : [];
+        let iterValues: string[] = (userValues) ? trim(userValues).split(/\s+/gi) : [];
         let ret = [];
-        let processed = {};
+        let processed: {[key: string]: boolean} = {};
 
-        //the idea is simply to loop over all values and then replace
-        //their generic values and filter out doubles
-        //this is more readable than the old indexed based solution
-        //and not really slower because we had to build up the index in our old solution
-        //anyway
+        // in this case we do not use lazy stream because it wont bring any code reduction
+        // or speedup
         for (let cnt = 0; cnt < iterValues.length; cnt++) {
             //avoid doubles
             if (iterValues[cnt] in processed) {
@@ -649,7 +685,7 @@ export module Implementation {
             return (<Function>func).call(source, event) !== false;
         } else {
             //either a function or a string can be passed in case of a string we have to wrap it into another function
-            //it it is not a plain executable code but a definition
+            //it is not a plain executable code but a definition
             let sourceCode = trim(<string>func);
             if (sourceCode.indexOf("function ") == 0) {
                 sourceCode = `return ${sourceCode} (event)`;

package/src/main/typescript/impl/util/AsyncQueue.ts

@@ -6,7 +6,7 @@ import {AsyncRunnable} from "./AsyncRunnable";
  *
  * Every callback must be of async runnable
  * which is sort of an extended promise which has
- * added a decicated cancel and start point
+ * added a dedicated cancel and start point
  *
  * This interface can be used as wrapper contract
  * for normal promises if needed.
@@ -21,12 +21,15 @@ export class AsynchronousQueue<T extends AsyncRunnable<any>> {
     constructor() {
     }
 
+    /**
+     * simple is empty accessor, returns true if queue is empty atm
+     */
     get isEmpty(): boolean {
         return !this.runnableQueue.length;
     }
 
     /**
-     * enequeues an element and starts the
+     * enqueues an element and starts the
      * asynchronous work loop if not already running
      *
      * @param element the element to be queued and processed
@@ -46,15 +49,39 @@ export class AsynchronousQueue<T extends AsyncRunnable<any>> {
         }
     }
 
-    dequeue(): T {
+    /**
+     * fetches the next element from the queue (first in first out order)
+     */
+    dequeue(): T | undefined{
         return this.runnableQueue.shift();
     }
 
+    /**
+     * clears up all elements from the queue
+     */
     cleanup() {
         this.currentlyRunning = null;
         this.runnableQueue.length = 0;
     }
 
+    /**
+     * cancels the currently running element and then cleans up the queue
+     * aka cancel the queue entirely
+     */
+    cancel() {
+        try {
+            if (this.currentlyRunning) {
+                this.currentlyRunning.cancel();
+            }
+        } finally {
+            this.cleanup();
+        }
+    }
+
+    private callForNextElementToProcess() {
+        this.runEntry();
+    }
+
     private appendElement(element: T) {
         //only if the first element is added we start with a trigger
         //otherwise a process already is running and not finished yet at that
@@ -88,18 +115,4 @@ export class AsynchronousQueue<T extends AsyncRunnable<any>> {
                 () => this.callForNextElementToProcess()
             ).start();
     }
-
-    cancel() {
-        try {
-            if (this.currentlyRunning) {
-                this.currentlyRunning.cancel();
-            }
-        } finally {
-            this.cleanup();
-        }
-    }
-
-    private callForNextElementToProcess() {
-        this.runEntry();
-    }
 }

package/src/main/typescript/impl/util/AsyncRunnable.ts

@@ -19,7 +19,9 @@
  * Ever object in the asynchronous queue needs to implement this interface
  *
  * the usage should be similar as a Promise from the outside.
- * but with a dedicated start point
+ * but with a dedicated start point. The problem why we cannot use
+ * promises here, is mostly related to the needed cancel functionality
+ * and that the queue expects a runnable as entry.
  *
  * from the implementation side it is mostly registering callbacks
  * and calling them at the appropriate time.
@@ -36,8 +38,8 @@ export interface AsyncRunnable<T> {
     cancel();
 
     /**
-     * callback for then functinality
-     * triggered when the asynch run is complete
+     * callback for then functionality
+     * triggered when the async run is complete
      *
      * the async runnable must register the passed function
      * and then triggers all the registered thens

package/src/main/typescript/impl/util/ExtDomQuery.ts

@@ -1,5 +1,5 @@
 import {Config, IValueHolder, Optional, DomQuery, DQ} from "mona-dish";
-import {EMPTY_STR, P_WINDOW_ID} from "../core/Const";
+import {P_WINDOW_ID} from "../core/Const";
 
 declare let window: any;
 
@@ -13,9 +13,9 @@ declare let window: any;
  */
 const IS_JSF_SOURCE = (source?: string): boolean => {
     return source && !!(source?.search(/\/javax\.faces\.resource.*\/jsf\.js.*/) != -1 ||
-        source?.search(/\/jsf\-development\.js.*/) != -1 ||
-        source?.search(/\/jsf\-uncompressed\.js.*/) != -1 ||
-        source?.search(/\/jsf[^\.]\.js.*ln\=javax.faces.*/gi) != -1);
+        source?.search(/\/jsf-development\.js.*/) != -1 ||
+        source?.search(/\/jsf-uncompressed\.js.*/) != -1 ||
+        source?.search(/\/jsf[^.]*\.js.*ln=javax.faces.*/gi) != -1);
 }
 
 /**
@@ -27,7 +27,7 @@ const IS_JSF_SOURCE = (source?: string): boolean => {
  * @constructor
  */
 const IS_INTERNAL_SOURCE = (source: string): boolean => {
-    return  source.search(/\/jsf[^\.]\.js.*ln\=myfaces.testscripts.*/gi) != -1;
+    return  source.search(/\/jsf[^.]*\.js.*ln=myfaces.testscripts.*/gi) != -1;
 }
 
 
@@ -131,7 +131,7 @@ export class ExtDomquery extends DQ {
     }
 
     globalEval(code: string, nonce ?: string): DQ {
-        return super.globalEval(code, nonce ?? this.nonce);
+        return new ExtDomquery(super.globalEval(code, nonce ?? this.nonce));
     }
 
     /**
@@ -150,12 +150,12 @@ export class ExtDomquery extends DQ {
      * byId producer
      *
      * @param selector id
+     * @param deep whether the search should go into embedded shadow dom elements
      * @return a DomQuery containing the found elements
      */
     static byId(selector: string | DomQuery | Element, deep = false): DomQuery {
         const ret = DomQuery.byId(selector, deep);
-        //return new ExtDomquery(ret);
-        return ret;
+        return new ExtDomquery(ret);
     }
 }
 

package/src/main/typescript/impl/xhrCore/EventData.ts

@@ -17,8 +17,8 @@ export class EventData {
         eventData.status = name;
 
         let sourceId: string = context.getIf(SOURCE)
-            .orElse(context.getIf(P_PARTIAL_SOURCE).value)
-            .orElse(context.getIf(CTX_PARAM_PASS_THR, P_PARTIAL_SOURCE).value).value;
+            .orElseLazy(() => context.getIf(P_PARTIAL_SOURCE).value)
+            .orElseLazy(() => context.getIf(CTX_PARAM_PASS_THR, P_PARTIAL_SOURCE).value).value;
         if (sourceId) {
             eventData.source = DQ.byId(sourceId, true).first().value.value;
         }

package/src/main/typescript/impl/xhrCore/RequestDataResolver.ts

@@ -46,7 +46,7 @@ import {ExtDomquery} from "../util/ExtDomQuery";
  */
 export function resolveHandlerFunc(requestContext: Config, responseContext: Config, funcName: string) {
     return responseContext.getIf(funcName)
-        .orElse(requestContext.getIf(funcName).value)
+        .orElseLazy(() =>requestContext.getIf(funcName).value)
         .orElse(EMPTY_FUNC).value;
 }
 
@@ -72,7 +72,7 @@ export function resolveFinalUrl(sourceForm: DomQuery, formData: XhrFormData, aja
  * @param event
  */
 export function resolveForm(requestCtx: Config, elem: DQ, event: Event): DQ {
-    const configId = requestCtx.value?.myfaces?.form ?? MF_NONE; //requestCtx.getIf(MYFACES, "form").orElse(MF_NONE).value;
+    const configId = requestCtx.value?.myfaces?.form ?? MF_NONE;
     return DQ
         .byId(configId, true)
         .orElseLazy(() => ExtLang.getForm(elem.getAsElem(0).value, event));
@@ -142,7 +142,7 @@ export function resolveDefaults(event: Event, opts: any = {}, el: Element | stri
     const resolvedEvent = event,
         options = new Config(opts).deepCopy,
         elem = DQ.byId(el || <Element>resolvedEvent.target, true),
-        elementId = elem.id, requestCtx = new Config({}),
+        elementId = elem.id.value, requestCtx = new Config({}),
         internalCtx = new Config({}), windowId = resolveWindowId(options),
         isResetValues = true === options.value?.resetValues;
 

package/src/main/typescript/impl/xhrCore/ResonseDataResolver.ts

@@ -102,9 +102,9 @@ export function resolveSourceForm(internalContext: Config, elem: DQ): DQ {
     let sourceFormId = internalContext.getIf(CTX_PARAM_SRC_FRM_ID);
     let sourceForm = new DQ(sourceFormId.isPresent() ? document.forms[sourceFormId.value] : null);
 
-    sourceForm = sourceForm.orElse(elem.parents(TAG_FORM))
-        .orElse(elem.querySelectorAll(TAG_FORM))
-        .orElse(DQ.querySelectorAll(TAG_FORM));
+    sourceForm = sourceForm.orElseLazy(() => elem.parents(TAG_FORM))
+        .orElseLazy(() => elem.querySelectorAll(TAG_FORM))
+        .orElseLazy(() => DQ.querySelectorAll(TAG_FORM));
 
     return sourceForm;
 }

package/src/main/typescript/impl/xhrCore/ResponseProcessor.ts

@@ -71,9 +71,13 @@ import {ExtDomquery} from "../util/ExtDomQuery";
 export class ResponseProcessor implements IResponseProcessor {
 
     constructor(private request: Config, private externalContext: Config, private internalContext: Config) {
-
     }
 
+    /**
+     * head replacement
+     * @param shadowDocument incoming shadow head data (aka cdata as xml reference or dom element)
+     * the data incoming must represent the html representation of the head itself one way or the other
+     */
     replaceHead(shadowDocument: XMLQuery | DQ) {
         let shadowHead = shadowDocument.querySelectorAll(TAG_HEAD);
         if (!shadowHead.isPresent()) {
@@ -85,6 +89,9 @@ export class ResponseProcessor implements IResponseProcessor {
         //delete all to avoid script and style overlays
         oldHead.querySelectorAll(SEL_SCRIPTS_STYLES).delete();
 
+        // we cannot replace new elements in the head, but we can eval the elements
+        // eval means the scripts will get attached (eval script attach method)
+        // but this is done by DomQuery not in this code
         this.storeForEval(shadowHead);
     }
 
@@ -108,6 +115,8 @@ export class ResponseProcessor implements IResponseProcessor {
         let resultingBody = <DQ>DQ.querySelectorAll(TAG_BODY).html(shadowInnerHTML);
         let updateForms = resultingBody.querySelectorAll(TAG_FORM);
 
+        // main difference, we cannot replace the body itself, but only its content
+        // we need a separate step for post processing the incoming attributes, like classes, styles etc...
         resultingBody.copyAttrs(shadowBody);
 
         this.storeForPostProcessing(updateForms, resultingBody);
@@ -157,10 +166,6 @@ export class ResponseProcessor implements IResponseProcessor {
         Implementation.sendError(errorData);
     }
 
-    private triggerOnError(errorData: ErrorData) {
-        this.externalContext.getIf(ON_ERROR).orElse(this.internalContext.getIf(ON_ERROR).value).orElse(EMPTY_FUNC).value(errorData);
-    }
-
     /**
      * process the redirect operation
      *
@@ -182,12 +187,16 @@ export class ResponseProcessor implements IResponseProcessor {
      */
     update(node: XMLQuery, cdataBlock: string) {
         let result = ExtDomquery.byId(node.id.value, true).outerHTML(cdataBlock, false, false);
-        let sourceForm = result?.parents(TAG_FORM).orElse(result.byTagName(TAG_FORM, true));
+        let sourceForm = result?.parents(TAG_FORM).orElseLazy(() => result.byTagName(TAG_FORM, true));
         if (sourceForm) {
             this.storeForPostProcessing(sourceForm, result);
         }
     }
 
+    /**
+     * Delete handler, simply deleetes the node referenced by the xml data
+     * @param node
+     */
     delete(node: XMLQuery) {
         DQ.byId(node.id.value, true).delete();
     }
@@ -214,7 +223,7 @@ export class ResponseProcessor implements IResponseProcessor {
     }
 
     /**
-     * insert handling, either before or after
+     * Insert handling, either before or after
      *
      * @param node
      */
@@ -239,7 +248,7 @@ export class ResponseProcessor implements IResponseProcessor {
     }
 
     /**
-     * handler for the case &lt;insert <&lt; before id="...
+     * Handler for the case &lt;insert <&lt; before id="...
      *
      * @param node the node hosting the insert data
      */
@@ -267,7 +276,7 @@ export class ResponseProcessor implements IResponseProcessor {
     }
 
     /**
-     * process the viewState update, update the affected
+     * Process the viewState update, update the affected
      * forms with their respective new viewstate values
      *
      */
@@ -298,7 +307,10 @@ export class ResponseProcessor implements IResponseProcessor {
     }
 
     /**
-     * post processing viewstate fixing
+     * Postprocessing view state fixing
+     * this appends basically the incoming view states to the forms.
+     * It is called from outside after all forms have been processed basically
+     * as last lifecycle step, before going into the next request.
      */
     fixViewStates() {
         Stream.ofAssoc<StateHolder>(this.internalContext.getIf(APPLIED_VST).orElse({}).value)
@@ -312,6 +324,10 @@ export class ResponseProcessor implements IResponseProcessor {
             });
     }
 
+    /**
+     * same as with view states before applies the incoming client windows as last step after the rest of the processing
+     * is done.
+     */
     fixClientWindow() {
         Stream.ofAssoc<StateHolder>(this.internalContext.getIf(APPLIED_CLIENT_WINDOW).orElse({}).value)
             .each((item: Array<any>) => {
@@ -331,7 +347,7 @@ export class ResponseProcessor implements IResponseProcessor {
         let eventData = EventData.createFromRequest(this.request.value, this.externalContext, SUCCESS);
 
         //because some frameworks might decorate them over the context in the response
-        let eventHandler = this.externalContext.getIf(ON_EVENT).orElse(this.internalContext.getIf(ON_EVENT).value).orElse(EMPTY_FUNC).value;
+        let eventHandler = this.externalContext.getIf(ON_EVENT).orElseLazy(() => this.internalContext.getIf(ON_EVENT).value).orElse(EMPTY_FUNC).value;
         Implementation.sendEvent(eventData, eventHandler);
     }
 
@@ -441,4 +457,8 @@ export class ResponseProcessor implements IResponseProcessor {
             node?.id?.value?.indexOf([P_CLIENT_WINDOW, separatorChar].join(EMPTY_STR)) != -1);
     }
 
+    private triggerOnError(errorData: ErrorData) {
+        this.externalContext.getIf(ON_ERROR).orElse(this.internalContext.getIf(ON_ERROR).value).orElse(EMPTY_FUNC).value(errorData);
+    }
+
 }