jsf.js_next_gen 4.0.0-beta-23 → 4.0.0

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

@@ -13,10 +13,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import {ArrayCollector, Config, DQ, Lang, LazyStream, Stream} from "mona-dish";
-import {EMPTY_STR, IDENT_ALL, IDENT_FORM, P_VIEWSTATE} from "../core/Const";
-import isString = Lang.isString;
-import {ExtConfig} from "../util/ExtDomQuery";
+import {Config, DQ, FormDataCollector, Stream} from "mona-dish";
+import {$nsp, EMPTY_STR, IDENT_NONE, P_VIEWSTATE} from "../core/Const";
+
+import {
+    encodeFormData,
+    fixEmmptyParameters, getFormInputsAsStream
+} from "../util/FileUtils";
+
+
+type ParamsMapper<V, K> = (key: V, item: K) => [V, K];
+const defaultParamsMapper: ParamsMapper<string, any> = (key, item) => [key, item];
 
 
 /**
@@ -27,9 +34,10 @@ import {ExtConfig} from "../util/ExtDomQuery";
  * due to api constraints on the HTML Form object in IE11
  * and due to the url encoding constraint given by the faces.js spec
  *
- * probably only one needed and one overlay!
- * the entire file input storing probably is redundant now
- * that dom query has been fixed //TODO check this
+ *
+ * internal storage format
+ * every value is stored as an array
+ * even scalar ones!
  */
 export class XhrFormData extends Config {
     /**
@@ -45,118 +53,53 @@ export class XhrFormData extends Config {
      * data collector from a given form
      *
      * @param dataSource either a form as DomQuery object or an encoded url string
-     * @param viewState the form view state or an external viewstate coming in as string
+     * @param paramsMapper a remapper for the params keys and values
      * @param executes the executes id list for the elements to being processed
      * @param partialIds partial ids to collect, to reduce the data sent down
      */
-    constructor(private dataSource: DQ | string, viewState?: string, executes?: string[], private partialIds?: string[]) {
+    constructor(private dataSource: DQ, private paramsMapper: ParamsMapper<string, any> = defaultParamsMapper, executes?: string[], private partialIds?: string[]) {
         super({});
-        //a call to getViewState before must pass the encoded line
-        //a call from getViewState passes the form element as datasource,
-        //so we have two call points
-        if (isString(dataSource)) {
-            this.assignEncodedString(<string>this.dataSource);
-        } else {
-            this.applyFormDataToConfig();
-        }
-        if('undefined' != typeof viewState) {
-            this.assignEncodedString(viewState)
-        }
-        if(executes) {
-            this.postInit(...executes);
-        }
-    }
-
-    /**
-     * generic post init code, for now, this peforms some post assign data post processing
-     * @param executes
-     */
-    postInit(...executes: Array<string>) {
-        let fetchInput = (id: string): DQ => {
-            if (id == IDENT_ALL) {
-                return DQ.querySelectorAllDeep("input[type='file']");
-            } else if (id == IDENT_FORM) {
-                return (<DQ>this.dataSource).querySelectorAllDeep("input[type='file']");
-            } else {
-                let element = DQ.byId(id, true);
-                return this.getFileInputs(element);
-            }
-        };
-
-        let inputExists = (item: DQ) => {
-            return item.isPresent();
-        };
-
-
-        this.isMultipartRequest = LazyStream.of(...executes)
-            .map(fetchInput)
-            .filter(inputExists)
-            .first().isPresent();
-    }
-
-    /**
-     * special case view state handling
-     *
-     * @param form the form holding the view state value
-     */
-    private applyViewState(form: DQ) {
-        let viewState = form.byId(P_VIEWSTATE, true).inputValue;
-        this.appendIf(viewState.isPresent(), P_VIEWSTATE).value = viewState.value;
-    }
-
-    /**
-     * assigns an url encoded string to this xhrFormData object
-     * as key value entry
-     * @param encoded
-     */
-    assignEncodedString(encoded: string) {
-        // this code filters out empty strings as key value pairs
-        let keyValueEntries = decodeURIComponent(encoded).split(/&/gi)
-                .filter(item => !!(item || '')
-                .replace(/\s+/g,''));
-        this.assignString(keyValueEntries);
-    }
-
-    /**
-     * assign a set of key value pairs passed as array ['key=val1', 'key2=val2']
-     * @param keyValueEntries
-     */
-    assignString(keyValueEntries: string[]) {
-        let toMerge = new ExtConfig({});
-
-        function splitToKeyVal(line: string) {
-            return line.split(/=(.*)/gi);
-        }
-
-        function fixKeyWithoutVal(keyVal: string[]) {
-            return keyVal.length < 3 ? [keyVal?.[0] ?? [], keyVal?.[1] ?? []] : keyVal;
-        }
-
-        Stream.of(...keyValueEntries)
-            //split only the first =
-            .map(line => splitToKeyVal(line))
-            //special case of having keys without values
-            .map(keyVal => fixKeyWithoutVal(keyVal))
-            .each(keyVal => {
-                toMerge.append(keyVal[0] as string).value = keyVal?.splice(1)?.join("") ?? "";
-            });
-        //merge with overwrite but no append! (aka no double entries are allowed)
-        this.shallowMerge(toMerge);
+        //encode and append the issuing item if not a partial ids array of ids is passed
+        /*
+         * Spec. 13.3.1
+         * Collect and encode input elements.
+         * Additionally the hidden element jakarta.faces.ViewState
+         * Enhancement partial page submit
+         */
+        this.resolveRequestType(this.dataSource, executes);
+        this.encodeSubmittableFields(this.dataSource, this.partialIds);
+        this.applyViewState(this.dataSource);
     }
 
     /**
      * @returns a Form data representation, this is needed for file submits
      */
     toFormData(): FormData {
-        let ret: any = new FormData();
-        this.appendInputs(ret);
-        return ret;
-    }
+        /*
+         * expands key: [item1, item2]
+         * to: [{key: key,  value: item1}, {key: key, value: item2}]
+         */
+        let expandAssocArray = ([key, item]) =>
+            Stream.of(...(item as Array<any>)).map(value => {
+                return {key, value};
+            });
+
+        /*
+         * remaps the incoming {key, value} tuples
+         * to naming container prefixed keys and values
+         */
+        let remapForNamingContainer = ({key, value}) => {
+            key = this.remapKeyForNamingContainer(key);
+            return {key, value}
+        };
 
-    resolveSubmitIdentifier(elem: HTMLInputElement) {
-        let identifier = elem.name;
-        identifier = ((elem?.name ?? "").replace(/s+/gi, "") == "") ? elem.id : identifier;
-        return identifier;
+        /*
+         * collects everything into a FormData object
+         */
+        return  Stream.ofAssoc(this.value)
+            .flatMap(expandAssocArray)
+            .map(remapForNamingContainer)
+            .collect(new FormDataCollector() as any);
     }
 
     /**
@@ -165,54 +108,33 @@ export class XhrFormData extends Config {
      * @param defaultStr optional default value if nothing is there to encode
      */
     toString(defaultStr = EMPTY_STR): string {
-        if (this.isAbsent()) {
-            return defaultStr;
-        }
-        let entries = LazyStream.of(...Object.keys(this.value))
-            .filter(key => this.value.hasOwnProperty(key))
-            .flatMap(key => Stream.of(...this.value[key]).map(val => [key, val]).collect(new ArrayCollector()))
-            .map(keyVal => {
-                return `${encodeURIComponent(keyVal[0])}=${encodeURIComponent(keyVal[1])}`;
-            })
-            .collect(new ArrayCollector());
-
-        return entries.join("&")
+        return encodeFormData(this, this.paramsMapper, defaultStr);
     }
 
     /**
-     * helper to fetch all file inputs from as given root element
-     * @param rootElement
-     * @private
+     * generic post init code, for now, this performs some post assign data post-processing
+     * @param executes the executable dom nodes which need to be processed into the form data, which we can send
+     * in our ajax request
      */
-    private getFileInputs(rootElement: DQ): DQ {
-        const rootFileInputs = rootElement
-            .filter(elem => elem.matchesSelector("input[type='file']"))
-        const childFileInputs = rootElement
-            .querySelectorAll("input[type='file']");
-
-        return rootFileInputs.concat(childFileInputs);
+    private resolveRequestType(rootElement: DQ, executes?: Array<string>) {
+        if (!executes || executes.indexOf(IDENT_NONE) != -1) {
+            return;
+        }
+        this.isMultipartRequest = rootElement.isMultipartCandidate(true);
     }
 
     /**
-     * encode the given fields and apply the view state
-     * @private
+     * special case view state handling
+     *
+     * @param form the form holding the view state value
      */
-    private applyFormDataToConfig() {
-        //encode and append the issuing item if not a partial ids array of ids is passed
-        /*
-         * Spec. 13.3.1
-         * Collect and encode input elements.
-         * Additionally the hidden element jakarta.faces.ViewState
-         * Enhancement partial page submit
-         *
-         */
-        this.encodeSubmittableFields(this, <DQ>this.dataSource, this.partialIds);
-
-        if (this.getIf(P_VIEWSTATE).isPresent()) {
+    private applyViewState(form: DQ) {
+        if (this.getIf($nsp(P_VIEWSTATE)).isPresent()) {
             return;
         }
-
-        this.applyViewState(<DQ>this.dataSource);
+        let viewStateElement = form.querySelectorAllDeep(`[name*='${$nsp(P_VIEWSTATE)}'`);
+        let viewState = viewStateElement.inputValue;
+        this.appendIf(viewState.isPresent(), this.remapKeyForNamingContainer(viewStateElement.name.value)).value = viewState.value;
     }
 
     /**
@@ -221,28 +143,19 @@ export class XhrFormData extends Config {
      * @param {Node} parentItem - form element item is nested in
      * @param {Array} partialIds - ids fo PPS
      */
-    private encodeSubmittableFields(targetBuf: Config,
-                                    parentItem: DQ, partialIds ?: string[]) {
-        let toEncode = null;
-        if (this.partialIds && this.partialIds.length) {
-            // in case of our myfaces reduced ppr we
-            // only submit the partials
-            this._value = {};
-            toEncode = new DQ(...this.partialIds);
-
-        } else {
-            if (parentItem.isAbsent()) throw 'NO_PAR_ITEM';
-            toEncode = parentItem;
-        }
+    private encodeSubmittableFields(parentItem: DQ, partialIds ?: string[]) {
 
-        //lets encode the form elements
-        this.shallowMerge(toEncode.deepElements.encodeFormElement());
+        const formInputs = getFormInputsAsStream(parentItem);
+        const mergeIntoThis = ([key, value]) => this.append(key).value = value;
+        const namingContainerRemap = ([key, value]) => this.paramsMapper(key as string, value);
+
+        formInputs
+            .map(fixEmmptyParameters)
+            .map(namingContainerRemap)
+            .each(mergeIntoThis);
     }
 
-    private appendInputs(ret: any) {
-        Stream.of(...Object.keys(this.value))
-            .each(key => {
-                Stream.of(...this.value[key]).each(item => ret.append(key, item));
-            });
+    private remapKeyForNamingContainer(key: string): string {
+        return this.paramsMapper(key, "")[0];
     }
 }

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

@@ -15,7 +15,7 @@
  */
 
 import {AsyncRunnable} from "../util/AsyncRunnable";
-import {Config, DQ, Stream} from "mona-dish";
+import {Config, DQ, DQ$, Stream} from "mona-dish";
 import {Implementation} from "../AjaxImpl";
 
 import {XhrFormData} from "./XhrFormData";
@@ -23,11 +23,12 @@ import {ErrorData} from "./ErrorData";
 import {EventData} from "./EventData";
 import {ExtLang} from "../util/Lang";
 import {
+    $faces,
     BEGIN,
     COMPLETE,
     CONTENT_TYPE,
     CTX_PARAM_MF_INTERNAL,
-    CTX_PARAM_PASS_THR,
+    CTX_PARAM_REQ_PASS_THR,
     ERROR,
     HEAD_FACES_REQ,
     MALFORMEDXML,
@@ -36,23 +37,29 @@ import {
     ON_EVENT, P_EXECUTE,
     REQ_ACCEPT,
     REQ_TYPE_GET,
-    REQ_TYPE_POST,
+    REQ_TYPE_POST, SOURCE,
     STATE_EVT_TIMEOUT,
     STD_ACCEPT,
     URL_ENCODED,
-    VAL_AJAX
+    VAL_AJAX, IDENT_NONE
 } from "../core/Const";
-import {resolveFinalUrl, resolveHandlerFunc} from "./RequestDataResolver";
+import {
+    resolveFinalUrl,
+    resolveHandlerFunc,
+    resoveNamingContainerMapper
+} from "./RequestDataResolver";
 import failSaveExecute = ExtLang.failSaveExecute;
+import {ExtConfig} from "../util/ExtDomQuery";
 
 /**
  * Faces XHR Request Wrapper
- * as Asyncrunnable for our Asynchronous queue
+ * as AsyncRunnable for our Asynchronous queue
  *
  * The idea is that we basically just enqueue
  * a single ajax request into our queue
  * and let the queue do the processing.
  *
+ *
  */
 
 export class XhrRequest implements AsyncRunnable<XMLHttpRequest> {
@@ -64,15 +71,15 @@ export class XhrRequest implements AsyncRunnable<XMLHttpRequest> {
     /**
      * helper support so that we do not have to drag in Promise shims
      */
-    private catchFuncs: Array<Function> = [];
-    private thenFunc: Array<Function> = [];
+    private catchFunctions: Array<Function> = [];
+    private thenFunctions: Array<Function> = [];
 
     /**
-     * Reqired Parameters
+     * Required Parameters
      *
      * @param source the issuing element
      * @param sourceForm the form which is related to the issuing element
-     * @param requestContext the request context with allö pass through values
+     * @param requestContext the request context with all pass through values
      *
      * Optional Parameters
      *
@@ -81,12 +88,12 @@ export class XhrRequest implements AsyncRunnable<XMLHttpRequest> {
      * @param timeout optional xhr timeout
      * @param ajaxType optional request type, default "POST"
      * @param contentType optional content type, default "application/x-www-form-urlencoded"
-     * @param xhrObject optional xhr object which must fullfill the XMLHTTPRequest api, default XMLHttpRequest
+     * @param xhrObject optional xhr object which must fulfill the XMLHTTPRequest api, default XMLHttpRequest
      */
     constructor(
         private source: DQ,
         private sourceForm: DQ,
-        private requestContext: Config,
+        private requestContext: ExtConfig,
         private internalContext: Config,
         private partialIdsArray = [],
         private timeout = NO_TIMEOUT,
@@ -94,10 +101,10 @@ export class XhrRequest implements AsyncRunnable<XMLHttpRequest> {
         private contentType = URL_ENCODED,
         private xhrObject = new XMLHttpRequest()
     ) {
-        /*
-        * we omit promises here
-        * some browsers do not support it and we do not need shim code
-        */
+
+        // we omit promises here because we have to deal with cancel functionality,
+        // and promises to not provide that (yet) instead we have our async queue
+        // which uses an api internally, which is very close to promises
         this.registerXhrCallbacks((data: any) => {
             this.resolve(data)
         }, (data: any) => {
@@ -111,70 +118,75 @@ export class XhrRequest implements AsyncRunnable<XMLHttpRequest> {
         let xhrObject = this.xhrObject;
 
         let executesArr = () => {
-            return this.requestContext.getIf(CTX_PARAM_PASS_THR, P_EXECUTE).get("none").value.split(/\s+/gi);
+            return this.requestContext.getIf(CTX_PARAM_REQ_PASS_THR, P_EXECUTE).get(IDENT_NONE).value.split(/\s+/gi);
         };
-        try {
 
-            let formElement = this.sourceForm.getAsElem(0).value;
-            let viewState = (window?.faces ?? window?.jsf).getViewState(formElement);
-            //encoded we need to decode
-            //We generated a base representation of the current form
-            //in case someone has overloaded the viewstate with addtional decorators we merge
-            //that in, there is no way around it, the spec allows it and getViewState
-            //must be called, so whatever getViewState delivers has higher priority then
-            //whatever the formData object delivers
-            //the partialIdsArray arr is almost deprecated legacy code where we allowed to send a separate list of partial
-            //ids for reduced load and server processing, this will be removed soon, we can handle the same via execute
-            //anyway TODO remove the partial ids array
-            let formData: XhrFormData = new XhrFormData(this.sourceForm, viewState, executesArr(), this.partialIdsArray);
+        try {
+            // encoded we need to decode
+            // We generated a base representation of the current form
+            // in case someone has overloaded the viewState with additional decorators we merge
+            // that in, there is no way around it, the spec allows it and getViewState
+            // must be called, so whatever getViewState delivers has higher priority then
+            // whatever the formData object delivers
+            // the partialIdsArray arr is almost deprecated legacy code where we allowed to send a separate list of partial
+            // ids for reduced load and server processing, this will be removed soon, we can handle the same via execute
+            // anyway TODO reimplement the partial ids array, we still do not have it in jsf the way we need it
+            let formData: XhrFormData = new XhrFormData(this.sourceForm, resoveNamingContainerMapper(this.internalContext), executesArr(), this.partialIdsArray);
 
             this.contentType = formData.isMultipartRequest ? "undefined" : this.contentType;
 
-            //next step the pass through parameters are merged in for post params
+            // next step the pass through parameters are merged in for post params
+            this.requestContext.$nspEnabled = false;
             let requestContext = this.requestContext;
-            let passThroughParams = requestContext.getIf(CTX_PARAM_PASS_THR);
+            let requestPassThroughParams = requestContext.getIf(CTX_PARAM_REQ_PASS_THR) as ExtConfig;
 
+            // we are turning off here the jsf, faces remapping because we are now dealing with
+            // pass-through parameters
+            requestPassThroughParams.$nspEnabled = false;
             // this is an extension where we allow pass through parameters to be sent down additionally
             // this can be used and is used in the impl to enrich the post request parameters with additional
             // information
-            formData.shallowMerge(passThroughParams, true, true);
+            try {
+                formData.shallowMerge(requestPassThroughParams, true, true);
+            } finally {
+                this.requestContext.$nspEnabled = true;
+                requestPassThroughParams.$nspEnabled = true;
+            }
 
-            this.responseContext = passThroughParams.deepCopy;
+            this.responseContext = requestPassThroughParams.deepCopy;
 
-            //we have to shift the internal passthroughs around to build up our response context
+            // we have to shift the internal passthroughs around to build up our response context
             let responseContext = this.responseContext;
 
             responseContext.assign(CTX_PARAM_MF_INTERNAL).value = this.internalContext.value;
 
-            //per spec the onevent and onerrors must be passed through to the response
+            // per spec the onevent and onerror handlers must be passed through to the response
             responseContext.assign(ON_EVENT).value = requestContext.getIf(ON_EVENT).value;
             responseContext.assign(ON_ERROR).value = requestContext.getIf(ON_ERROR).value;
 
             xhrObject.open(this.ajaxType, resolveFinalUrl(this.sourceForm, formData, this.ajaxType), true);
 
-            //adding timeout
+            // adding timeout
             this.timeout ? xhrObject.timeout = this.timeout : null;
 
-            //a bug in the xhr stub library prevents the setRequestHeader to be properly executed on fake xhr objects
-            //normal browsers should resolve this
-            //tests can quietly fail on this one
+            // a bug in the xhr stub library prevents the setRequestHeader to be properly executed on fake xhr objects
+            // normal browsers should resolve this
+            // tests can quietly fail on this one
             if(this.contentType != "undefined") {
                 ignoreErr(() => xhrObject.setRequestHeader(CONTENT_TYPE, `${this.contentType}; charset=utf-8`));
             }
 
             ignoreErr(() => xhrObject.setRequestHeader(HEAD_FACES_REQ, VAL_AJAX));
 
-            //probably not needed anymore, will test this
-            //some webkit based mobile browsers do not follow the w3c spec of
+            // probably not needed anymore, will test this
+            // some webkit based mobile browsers do not follow the w3c spec of
             // setting, they accept headers automatically
             ignoreErr(() => xhrObject.setRequestHeader(REQ_ACCEPT, STD_ACCEPT));
 
             this.sendEvent(BEGIN);
-
             this.sendRequest(formData);
-
         } catch (e) {
-            //_onError//_onError
+            // _onError
             this.handleError(e);
         }
         return this;
@@ -189,32 +201,31 @@ export class XhrRequest implements AsyncRunnable<XMLHttpRequest> {
     }
 
     resolve(data: any) {
-        Stream.of(...this.thenFunc).reduce((inputVal: any, thenFunc: any) => {
+        Stream.of(...this.thenFunctions).reduce((inputVal: any, thenFunc: any) => {
             return thenFunc(inputVal);
         }, data);
     }
 
     reject(data: any) {
-        Stream.of(...this.catchFuncs).reduce((inputVal: any, catchFunc: any) => {
+        Stream.of(...this.catchFunctions).reduce((inputVal: any, catchFunc: any) => {
             return catchFunc(inputVal);
         }, data);
     }
 
     catch(func: (data: any) => any): AsyncRunnable<XMLHttpRequest> {
-        this.catchFuncs.push(func);
+        this.catchFunctions.push(func);
         return this;
     }
 
     finally(func: () => void): AsyncRunnable<XMLHttpRequest> {
-        //no ie11 support we probably are going to revert to shims for that one
-        this.catchFuncs.push(func);
-        this.thenFunc.push(func);
+        // no ie11 support we probably are going to revert to shims for that one
+        this.catchFunctions.push(func);
+        this.thenFunctions.push(func);
         return this;
     }
 
     then(func: (data: any) => any): AsyncRunnable<XMLHttpRequest> {
-        //this.$promise.then(func);
-        this.thenFunc.push(func);
+        this.thenFunctions.push(func);
         return this;
     }
 
@@ -241,10 +252,10 @@ export class XhrRequest implements AsyncRunnable<XMLHttpRequest> {
             this.onDone(this.xhrObject, resolve);
         };
         xhrObject.onerror = (errorData: any) => {
+
             // some browsers trigger an error when cancelling a request internally
             // in this case we simply ignore the request and clear up the queue, because
             // it is not safe anymore to proceed with the current queue
-
             // This bypasses a Safari issue where it keeps requests hanging after page unload
             // and then triggers a cancel error on then instead of just stopping
             // and clearing the code
@@ -258,7 +269,7 @@ export class XhrRequest implements AsyncRunnable<XMLHttpRequest> {
     }
 
     private isCancelledResponse(currentTarget: XMLHttpRequest): boolean {
-        return currentTarget?.status === 0 && //cancelled by browser
+        return currentTarget?.status === 0 && // cancelled by browser
             currentTarget?.readyState === 4 &&
             currentTarget?.responseText === '' &&
             currentTarget?.responseXML === null;
@@ -284,13 +295,14 @@ export class XhrRequest implements AsyncRunnable<XMLHttpRequest> {
 
         this.sendEvent(COMPLETE);
 
-        //malforms always result in empty response xml
+        // malformed responses always result in empty response xml
+        // per spec a valid response cannot be empty
         if (!this?.xhrObject?.responseXML) {
             this.handleMalFormedXML(resolve);
             return;
         }
 
-        (window?.faces ?? window.jsf).ajax.response(this.xhrObject, this.responseContext.value ?? {});
+        $faces().ajax.response(this.xhrObject, this.responseContext.value ?? {});
     }
 
     private handleMalFormedXML(resolve: Function) {
@@ -300,9 +312,9 @@ export class XhrRequest implements AsyncRunnable<XMLHttpRequest> {
             status: MALFORMEDXML,
             responseCode: 200,
             responseText: this.xhrObject?.responseText,
-            source: {
-                id: this.source.id.value
-            }
+            // we remap the element just in case it gets replaced
+            // it will be unremapped
+            source:  this.source.id.value
         };
         try {
             this.handleError(errorData, true);
@@ -311,7 +323,7 @@ export class XhrRequest implements AsyncRunnable<XMLHttpRequest> {
             // reject would clean up the queue
             resolve(errorData);
         }
-        //non blocking non clearing
+        // non blocking non clearing
     }
 
     private onDone(data: any, resolve: Consumer<any>) {
@@ -330,10 +342,10 @@ export class XhrRequest implements AsyncRunnable<XMLHttpRequest> {
     private sendRequest(formData: XhrFormData) {
         let isPost = this.ajaxType != REQ_TYPE_GET;
         if (formData.isMultipartRequest) {
-            //in case of a multipart request we send in a formData object as body
+            // in case of a multipart request we send in a formData object as body
             this.xhrObject.send((isPost) ? formData.toFormData() : null);
         } else {
-            //in case of a normal request we send it normally
+            // in case of a normal request we send it normally
             this.xhrObject.send((isPost) ? formData.toString() : null);
         }
     }
@@ -344,14 +356,15 @@ export class XhrRequest implements AsyncRunnable<XMLHttpRequest> {
     private sendEvent(evtType: string) {
         let eventData = EventData.createFromRequest(this.xhrObject, this.requestContext, evtType);
         try {
-            //user code error, we might cover
-            //this in onError but also we cannot swallow it
-            //we need to resolve the local handlers lazily,
-            //because some frameworks might decorate them over the context in the response
+            // User code error, we might cover
+            // this in onError, but also we cannot swallow it.
+            // We need to resolve the local handlers lazily,
+            // because some frameworks might decorate them over the context in the response
             let eventHandler = resolveHandlerFunc(this.requestContext, this.responseContext, ON_EVENT);
 
             Implementation.sendEvent(eventData, eventHandler);
         } catch (e) {
+            e.source = e?.source ?? this.requestContext.getIf(SOURCE).value;
             this.handleError(e);
             throw e;
         }
@@ -363,5 +376,4 @@ export class XhrRequest implements AsyncRunnable<XMLHttpRequest> {
         let eventHandler = resolveHandlerFunc(this.requestContext, this.responseContext, ON_ERROR);
         Implementation.sendError(errorData, eventHandler);
     }
-
 }