jsf.js_next_gen 4.0.0-beta-23 → 4.0.0

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

@@ -39,9 +39,12 @@ const IS_FACES_SOURCE = (source?: string): boolean => {
 }
 
 /**
- * namespace myfaces.testscripts can be used as extension point for internal
- * tests, those will be handled similarly to faces.js - regarding
- * reload blocking on ajax requests
+ * namespace myfaces\.testscripts can be used as extension point for internal
+ * tests, those will be handled similarly to faces.js, in regard
+ * to reload blocking on ajax requests
+ *
+ * Note: atm not used, used to be used in the old implementation
+ * but still is reserved for now
  *
  * @param source the source to check
  * @constructor
@@ -55,21 +58,21 @@ const ATTR_SRC = 'src';
 
 /**
  * Extension which adds implementation specific
- * meta data to our dom query
+ * meta-data to our dom query
  *
  * Usage
  * el = new ExtDQ(oldReference)
  * nonce = el.nonce
  * windowId = el.getWindowId
  */
-export class ExtDomquery extends DQ {
+export class ExtDomQuery extends DQ {
 
     static get windowId() {
-        return new ExtDomquery(document.body).windowId;
+        return new ExtDomQuery(document.body).windowId;
     }
 
     static get nonce(): string {
-        return new ExtDomquery(document.body).nonce;
+        return new ExtDomQuery(document.body).nonce;
     }
 
     get windowId(): string | null {
@@ -112,7 +115,7 @@ export class ExtDomquery extends DQ {
         let curScript = new DQ(document.currentScript);
         //since our baseline atm is ie11 we cannot use document.currentScript globally
         if (!!this.extractNonce(curScript)) {
-            // fastpath for modern browsers
+            // fast-path for modern browsers
             return this.extractNonce(curScript);
         }
         // fallback if the currentScript method fails, we just search the jsf tags for nonce, this is
@@ -130,26 +133,20 @@ export class ExtDomquery extends DQ {
         return null;
     }
 
-
-
-    private extractNonce(curScript: DomQuery) {
-        return (curScript.getAsElem(0).value as HTMLElement)?.nonce ?? curScript.attr("nonce").value;
-    }
-
     static searchJsfJsFor(item: RegExp): Optional<String> {
-        return new ExtDomquery(document).searchJsfJsFor(item);
+        return new ExtDomQuery(document).searchJsfJsFor(item);
     }
 
     /**
-     * searches the embedded faces.js for items like separator char etc..
+     * searches the embedded faces.js for items like separator char etc.
      * expects a match as variable under position 1 in the result match
-     * @param rexp
+     * @param regExp
      */
-    searchJsfJsFor(rexp: RegExp): Optional<string> {
+    searchJsfJsFor(regExp: RegExp): Optional<string> {
         //perfect application for lazy stream
         return DQ.querySelectorAll("script[src], link[src]").lazyStream
             .filter(item => IS_FACES_SOURCE(item.attr(ATTR_SRC).value))
-            .map(item => item.attr(ATTR_SRC).value.match(rexp))
+            .map(item => item.attr(ATTR_SRC).value.match(regExp))
             .filter(item => item != null && item.length > 1)
             .map((result: string[]) => {
                 return decodeURIComponent(result[1]);
@@ -157,22 +154,24 @@ export class ExtDomquery extends DQ {
     }
 
     globalEval(code: string, nonce ?: string): DQ {
-        return new ExtDomquery(super.globalEval(code, nonce ?? this.nonce));
+        return new ExtDomQuery(super.globalEval(code, nonce ?? this.nonce));
     }
 
+    // called from base class runScripts, do not delete
+    // noinspection JSUnusedGlobalSymbols
     globalEvalSticky(code: string, nonce ?: string): DQ {
-        return new ExtDomquery(super.globalEvalSticky(code, nonce ?? this.nonce));
+        return new ExtDomQuery(super.globalEvalSticky(code, nonce ?? this.nonce));
     }
 
     /**
      * decorated run scripts which takes our jsf extensions into consideration
      * (standard DomQuery will let you pass anything)
      * @param sticky if set to true the internally generated element for the script is left in the dom
-     * @param whilteListed
+     * @param whiteListed
      */
-    runScripts(sticky = false, whilteListed?: (src: string) => boolean): DomQuery {
+    runScripts(sticky = false, whiteListed?: (src: string) => boolean): DomQuery {
         const whitelistFunc = (src: string): boolean => {
-            return (whilteListed?.(src) ?? true) && !IS_FACES_SOURCE(src) && !IS_INTERNAL_SOURCE(src);
+            return (whiteListed?.(src) ?? true) && !IS_FACES_SOURCE(src) && !IS_INTERNAL_SOURCE(src);
         };
         return super.runScripts(sticky, whitelistFunc);
     }
@@ -183,7 +182,7 @@ export class ExtDomquery extends DQ {
      * @param suppressDoubleIncludes checks for existing elements in the head before running the insert
      */
     runHeadInserts(suppressDoubleIncludes = true): void {
-        let head = ExtDomquery.byId(document.head);
+        let head = ExtDomQuery.byId(document.head);
         //automated nonce handling
         let processedScripts = [];
 
@@ -197,12 +196,13 @@ export class ExtDomquery extends DQ {
             }
             const tagName = element.tagName.value;
             if(!tagName) {
-                // textnode
+                // text node they do not have tag names, so we can process them as they are without
+                // any further ado
                 return true;
             }
             let reference = element.attr("href")
-                .orElse(element.attr("src").value)
-                .orElse(element.attr("rel").value);
+                .orElseLazy(() => element.attr("src").value)
+                .orElseLazy(() => element.attr("rel").value);
 
             if (!reference.isPresent()) {
                 return true;
@@ -217,14 +217,14 @@ export class ExtDomquery extends DQ {
             .each(element => {
                 if(element.tagName.value != "SCRIPT") {
                     //we need to run runScripts properly to deal with the rest
-                    new ExtDomquery(...processedScripts).runScripts(true);
+                    new ExtDomQuery(...processedScripts).runScripts(true);
                     processedScripts = [];
                     head.append(element);
                 } else {
                     processedScripts.push(element);
                 }
             });
-        new ExtDomquery(...processedScripts).runScripts(true);
+        new ExtDomQuery(...processedScripts).runScripts(true);
     }
 
 
@@ -235,15 +235,21 @@ export class ExtDomquery extends DQ {
      * @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 {
+    static byId(selector: string | DomQuery | Element, deep = false): ExtDomQuery {
         const ret = DomQuery.byId(selector, deep);
-        return new ExtDomquery(ret);
+        return new ExtDomQuery(ret);
     }
 
+    private extractNonce(curScript: DomQuery) {
+        return (curScript.getAsElem(0).value as HTMLElement)?.nonce ?? curScript.attr("nonce").value;
+    }
 
+    filter(func: (item: DomQuery) => boolean): ExtDomQuery {
+        return new ExtDomQuery(super.filter(func));
+    }
 }
 
-export const ExtDQ = ExtDomquery;
+export const ExtDQ = ExtDomQuery;
 
 /**
  * in order to reduce the number of interception points for the fallbacks we add
@@ -251,18 +257,20 @@ export const ExtDQ = ExtDomquery;
  */
 export class ExtConfig extends  Config {
 
+    $nspEnabled = true;
+
     constructor(root: any) {
         super(root);
     }
 
     assignIf(condition: boolean, ...accessPath): IValueHolder<any> {
-        const acessPathMapped = this.remap(accessPath);
-        return super.assignIf(condition, ...acessPathMapped);
+        const accessPathMapped = this.remap(accessPath);
+        return super.assignIf(condition, ...accessPathMapped);
     }
 
     assign(...accessPath): IValueHolder<any> {
-        const acessPathMapped = this.remap(accessPath);
-        return super.assign(...acessPathMapped);
+        const accessPathMapped = this.remap(accessPath);
+        return super.assign(...accessPathMapped);
     }
 
     append(...accessPath): IValueHolder<any> {
@@ -270,13 +278,13 @@ export class ExtConfig extends  Config {
     }
 
     appendIf(condition: boolean, ...accessPath): IValueHolder<any> {
-        const acessPathMapped = this.remap(accessPath);
-        return super.appendIf(condition, ...acessPathMapped);
+        const accessPathMapped = this.remap(accessPath);
+        return super.appendIf(condition, ...accessPathMapped);
     }
 
     getIf(...accessPath): Config {
-        const acessPathMapped = this.remap(accessPath);
-        return super.getIf(...acessPathMapped);
+        const accessPathMapped = this.remap(accessPath);
+        return super.getIf(...accessPathMapped);
     }
 
     get(defaultVal: any): Config {
@@ -315,10 +323,15 @@ export class ExtConfig extends  Config {
         return new ExtConfig(super.deepCopy$());
     }
 
-
-    private remap(accessPath: any[]) {
+    /**
+     * helper to remap the namespaces of an array of access paths
+     * @param accessPath the access paths to be remapped
+     * @private returns an array of access paths with version remapped namespaces
+     */
+    private remap(accessPath: string[]): string[] {
+        if(!this.$nspEnabled) {
+            return accessPath;
+        }
         return Stream.of(...accessPath).map(key => $nsp(key)).collect(new ArrayCollector());
     }
-
-
 }

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

@@ -0,0 +1,104 @@
+import {ArrayCollector, Config, DomQuery, DQ, LazyStream, Stream} from "mona-dish";
+import {ExtDomQuery} from "./ExtDomQuery";
+import {$faces, EMPTY_STR} from "../core/Const";
+
+/*
+ * various routines for encoding and decoding url parameters
+ * into configs and vice versa
+ */
+
+
+/**
+ * encodes a given form data into a url encoded string
+ * @param formData the form data config object
+ * @param paramsMapper the params mapper
+ * @param defaultStr a default string if nothing comes out of it
+ */
+export function encodeFormData(formData: Config,
+                               paramsMapper = (inStr, inVal) => [inStr, inVal],
+                               defaultStr = EMPTY_STR): string {
+    if (formData.isAbsent()) {
+        return defaultStr;
+    }
+    const assocValues = formData.value;
+
+    const expandValueArrAndRename = key => Stream.of(...assocValues[key]).map(val => paramsMapper(key, val));
+    const isPropertyKey = key => assocValues.hasOwnProperty(key);
+    const isNotFile = ([, value]) => !(value instanceof ExtDomQuery.global().File);
+    const mapIntoUrlParam = keyVal => `${encodeURIComponent(keyVal[0])}=${encodeURIComponent(keyVal[1])}`;
+
+    const entries = LazyStream.of(...Object.keys(assocValues))
+        .filter(isPropertyKey)
+        .flatMap(expandValueArrAndRename)
+        //we cannot encode file elements that is handled by multipart requests anyway
+        .filter(isNotFile)
+        .map(mapIntoUrlParam)
+        .collect(new ArrayCollector());
+
+    return entries.join("&")
+}
+
+/**
+ * splits and decodes encoded values into strings containing of key=value
+ * @param encoded encoded string
+ */
+export function decodeEncodedValues(encoded: string): Stream<string[]> {
+    const filterBlanks = item => !!(item || '').replace(/\s+/g, '');
+    const splitKeyValuePair = line => {
+        let index = line.indexOf("=");
+        if (index == -1) {
+            return [line];
+        }
+        return [line.substring(0, index), line.substring(index + 1)];
+    };
+
+    let requestParamEntries = decodeURIComponent(encoded).split(/&/gi);
+    return Stream.of(...requestParamEntries)
+        .filter(filterBlanks)
+        .map(splitKeyValuePair)
+}
+
+
+/**
+ * gets all the input files and their corresponding file objects
+ * @param dataSource
+ */
+export function resolveFiles(dataSource: DQ): Stream<[string, File]> {
+
+    const expandFilesArr = ([key, files]) => Stream.of(...files).map(file => [key, file]);
+    const remapFileInput = fileInput => [fileInput.name.value || fileInput.id.value, fileInput.filesFromElem(0)];
+    return dataSource
+        .querySelectorAllDeep("input[type='file']")
+        .stream
+        .map(remapFileInput)
+        .flatMap(expandFilesArr);
+}
+
+
+export function fixEmmptyParameters(keyVal: any[]): [string, any] {
+    return (keyVal.length < 3 ? [keyVal?.[0] ?? [], keyVal?.[1] ?? []] : keyVal) as [string, any];
+}
+
+/**
+ * returns the decoded viewState from parentItem
+ * @param parentItem
+ */
+function resolveViewState(parentItem: DomQuery): Stream<string[] | [string, File]> {
+    const viewStateStr = $faces().getViewState(parentItem.getAsElem(0).value);
+
+    // we now need to decode it and then merge it into the target buf
+    // which hosts already our overrides (aka do not override what is already there(
+    // after that we need to deal with form elements on a separate level
+    return decodeEncodedValues(viewStateStr);
+}
+
+/**
+ * gets all the inputs under the form parentItem
+ * as stream
+ * @param parentItem
+ */
+export function getFormInputsAsStream(parentItem: DomQuery): Stream<string[] | [string, File]> {
+    const standardInputs = resolveViewState(parentItem);
+    const fileInputs = resolveFiles(parentItem);
+    return  standardInputs.concat(fileInputs as any)
+}

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

@@ -0,0 +1,89 @@
+/*! Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import {DomQuery, DQ, DQ$} from "mona-dish";
+import {$faces, $nsp, HTML_CLIENT_WINDOW, HTML_VIEWSTATE, P_CLIENT_WINDOW, P_VIEWSTATE} from "../core/Const";
+
+/**
+ * Builder for hidden inputs.
+ * ATM only ViewState and Client window
+ * are supported (per spec)
+ *
+ * Improves readability in the response processor!
+ */
+export class HiddenInputBuilder {
+    private namingContainerId?: string;
+    private parent?: DomQuery;
+    private namedViewRoot: boolean = false;
+    private readonly name: string;
+    private readonly template: string;
+
+    constructor(private selector: string) {
+        const isViewState = selector.indexOf($nsp(P_VIEWSTATE)) != -1;
+        this.name = isViewState ? P_VIEWSTATE : P_CLIENT_WINDOW
+        this.template = isViewState ? HTML_VIEWSTATE : HTML_CLIENT_WINDOW
+    }
+
+    withNamingContainerId(namingContainer: string): HiddenInputBuilder {
+        this.namingContainerId = namingContainer;
+        return this;
+    }
+
+    withParent(parent: DomQuery): HiddenInputBuilder {
+        this.parent = parent;
+        return this;
+    }
+
+    withNamedViewRoot(namedViewRoot: boolean): HiddenInputBuilder {
+        this.namedViewRoot = namedViewRoot;
+        return this;
+    }
+
+
+    build(): DomQuery {
+        const SEP = $faces().separatorchar;
+
+        let existingStates = DQ$(`[name*='${$nsp(this.name)}']`);
+        let cnt = existingStates.stream.map(state => {
+            let ident: string = state.id.orElse("-1").value;
+            ident = ident.substring(ident.lastIndexOf(SEP)+1);
+            return parseInt(ident);
+        })
+            .filter(item => !isNaN(item))
+            .reduce((item1, item2) => Math.max(item1, item2), -1).value;
+        //the maximum  new ident is the current max + 1
+        cnt++;
+
+
+        const newElement = DQ.fromMarkup($nsp(this.template));
+        newElement.id.value = ((this.namingContainerId?.length) ?
+            [this.namingContainerId,  $nsp(this.name),  cnt]:
+            [$nsp(this.name),  cnt]).join(SEP);
+
+        //name must be prefixed with the naming container id as well according to the jsdocs
+        if(this.namedViewRoot) {
+            newElement.name.value = (this.namingContainerId?.length) ?
+                [this.namingContainerId,  $nsp(this.name)].join(SEP): $nsp(this.name);
+        } else {
+            newElement.name.value = $nsp(this.name);
+        }
+
+
+        this?.parent?.append(newElement);
+        return newElement;
+    }
+}

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

@@ -13,13 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * todo replace singleton with module definition
- *
  */
 
 import {Lang as LangBase, Config, Optional, DomQuery, DQ, Stream} from "mona-dish";
 import {Messages} from "../i18n/Messages";
-import {EMPTY_STR, TAG_FORM} from "../core/Const";
+import {EMPTY_STR, HTML_TAG_FORM} from "../core/Const";
 import {getEventTarget} from "../xhrCore/RequestDataResolver";
 
 
@@ -38,11 +36,11 @@ export module ExtLang {
 
     //should be in lang, but for now here to avoid recursive imports, not sure if typescript still has a problem with those
     /**
-     * helper function to savely resolve anything
+     * helper function to safely resolve anything
      * this is not an elvis operator, it resolves
      * a value without exception in a tree and if
      * it is not resolvable then an optional of
-     * a default value is restored or Optional.empty
+     * a default value is restored or Optional\.empty
      * if none is given
      *
      * usage
@@ -51,7 +49,7 @@ export module ExtLang {
      * </code>
      *
      * @param resolverProducer a lambda which can produce the value
-     * @param defaultValue an optional default value if the producer failes to produce anything
+     * @param defaultValue an optional default value if the producer fails to produce anything
      * @returns an Optional of the produced value
      */
     export function failSaveResolve<T>(resolverProducer: () => T, defaultValue: T = null): Optional<T> {
@@ -75,10 +73,10 @@ export module ExtLang {
      * returns a given localized message upon a given key
      * basic java log like templating functionality is included
      *
-     * @param {String} key the key for the message
-     * @param {String} defaultMessage optional default message if none was found
+     * @param  key the key for the message
+     * @param  defaultMessage optional default message if none was found
      *
-     * Additionally you can pass additional arguments, which are used
+     * Additionally, you can pass additional arguments, which are used
      * in the same way java log templates use the params
      *
      * @param templateParams the param list to be filled in
@@ -106,15 +104,15 @@ export module ExtLang {
     }
 
     /**
-     * creates an exeption with additional internal parameters
+     * creates an exception with additional internal parameters
      * for extra information
      *
      * @param error
-     * @param {String} title the exception title
-     * @param {String} name  the exception name
-     * @param {String} callerCls the caller class
-     * @param {String} callFunc the caller function
-     * @param {String} message the message for the exception
+     * @param  title the exception title
+     * @param  name  the exception name
+     * @param  callerCls the caller class
+     * @param  callFunc the caller function
+     * @param  message the message for the exception
      */
     export function makeException(error: Error, title: string, name: string, callerCls: string, callFunc: string, message: string): Error {
 
@@ -124,14 +122,14 @@ export module ExtLang {
 
     /**
      * fetches a global config entry
-     * @param {String} configName the name of the configuration entry
-     * @param {Object} defaultValue
+     * @param  configName the name of the configuration entry
+     * @param  defaultValue
      *
      * @return either the config entry or if none is given the default value
      */
     export function getGlobalConfig(configName: string, defaultValue: any): any {
         /**
-         * note we could use exists but this is an heavy operation, since the config name usually
+         * note we could use exists but this is a heavy operation, since the config name usually
          * given this function here is called very often
          * is a single entry without . in between we can do the lighter shortcut
          */
@@ -139,7 +137,7 @@ export module ExtLang {
     }
 
     /**
-     * fetches the form in an fuzzy manner depending
+     * fetches the form in a fuzzy manner depending
      * on an element or event target.
      *
      * The idea is that according to the jsf spec
@@ -148,7 +146,7 @@ export module ExtLang {
      * This is fine, but since then html5 came into the picture with the form attribute the element
      * can be anywhere referencing its parent form.
      *
-     * Also theoretically you can have the case of an issuing element enclosing a set of forms
+     * Also, theoretically you can have the case of an issuing element enclosing a set of forms
      * (not really often used, but theoretically it could be input button allows to embed html for instance)
      *
      * So the idea is not to limit the issuing form determination to the spec case
@@ -160,25 +158,25 @@ export module ExtLang {
     export function getForm(elem: Element, event ?: Event): DQ | never {
 
         let queryElem = new DQ(elem);
-        let eventTarget = new DQ(getEventTarget(event));
+        let eventTarget = (event) ?  new DQ(getEventTarget(event)) : DomQuery.absent;
 
-        if (queryElem.isTag(TAG_FORM)) {
+        if (queryElem.isTag(HTML_TAG_FORM)) {
             return queryElem;
         }
 
         //html 5 for handling
-        if (queryElem.attr(TAG_FORM).isPresent()) {
-            let formId = queryElem.attr(TAG_FORM).value;
+        if (queryElem.attr(HTML_TAG_FORM).isPresent()) {
+            let formId = queryElem.attr(HTML_TAG_FORM).value;
             let foundForm = DQ.byId(formId, true);
             if (foundForm.isPresent()) {
                 return foundForm;
             }
         }
 
-        let form = queryElem.parents(TAG_FORM)
-            .orElseLazy(() => queryElem.byTagName(TAG_FORM, true))
-            .orElseLazy(() => eventTarget.parents(TAG_FORM))
-            .orElseLazy(() => eventTarget.byTagName(TAG_FORM))
+        let form = queryElem.firstParent(HTML_TAG_FORM)
+            .orElseLazy(() => queryElem.byTagName(HTML_TAG_FORM, true))
+            .orElseLazy(() => eventTarget.firstParent(HTML_TAG_FORM))
+            .orElseLazy(() => eventTarget.byTagName(HTML_TAG_FORM))
             .first();
 
         assertFormExists(form);
@@ -190,10 +188,11 @@ export module ExtLang {
      * gets the local or global options with local ones having higher priority
      * if no local or global one was found then the default value is given back
      *
-     * @param {String} configName the name of the configuration entry
-     * @param {String} localOptions the local options root for the configuration myfaces as default marker is added implicitely
+     * @param  configName the name of the configuration entry
+     * @param  localOptions the local options root for the configuration myfaces as default marker is added
+     * implicitly
      *
-     * @param {Object} defaultValue
+     * @param  defaultValue
      *
      * @return either the config entry or if none is given the default value
      */

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

@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 import {
-    EMPTY_STR,
+    EMPTY_STR, ERROR,
     ERROR_MESSAGE,
     ERROR_NAME,
     RESPONSE_TEXT,
-    RESPONSE_XML,
+    RESPONSE_XML, SERVER_ERROR,
     SOURCE,
     STATUS,
     UNKNOWN
@@ -49,7 +49,8 @@ export enum ErrorType {
 export class ErrorData extends EventData implements IErrorData {
 
     type: string = "error";
-    source: string;
+    source: HTMLElement;
+    sourceId: string;
     errorName: string;
     errorMessage: string;
 
@@ -63,12 +64,14 @@ export class ErrorData extends EventData implements IErrorData {
     serverErrorMessage: string;
     message: string;
 
-    constructor(source: string, errorName: string, errorMessage: string, responseText: string = null, responseXML: any = null, responseCode: string = "200", status: string = "UNKNOWN", type = ErrorType.CLIENT_ERROR) {
+    constructor(source: string, errorName: string, errorMessage: string, responseText: string = null, responseXML: any = null, responseCode: string = "200", status: string = "", type = ErrorType.CLIENT_ERROR) {
         super();
-        this.source = source;
-        this.type = "error";
+        this.source = document.getElementById(source);
+        this.sourceId = source;
+        this.type = ERROR;
         this.errorName = errorName;
-        this.message = this.errorMessage = errorMessage;
+        //tck requires that the type is prefixed to the message itself (jsdoc also) in case of a server error
+        this.message = this.errorMessage = (type == SERVER_ERROR) ? type + ": " + errorMessage : errorMessage;
         this.responseCode = responseCode;
         this.responseText = responseText;
         this.status = status;
@@ -81,10 +84,10 @@ export class ErrorData extends EventData implements IErrorData {
     }
 
     static fromClient(e: Error): ErrorData {
-        return new ErrorData("client", e?.name ?? '', e?.message ?? '', e?.stack ?? '');
+        return new ErrorData((e as any)?.source ?? "client", e?.name ?? EMPTY_STR, e?.message ?? EMPTY_STR, e?.stack ?? EMPTY_STR);
     }
 
-    static fromHttpConnection(source: any, name: string, message: string, responseText, responseCode: number, status: string = 'UNKNOWN'): ErrorData {
+    static fromHttpConnection(source: any, name: string, message: string, responseText, responseCode: number, status: string = EMPTY_STR): ErrorData {
         return new ErrorData(source, name, message, responseText, responseCode, `${responseCode}`, status, ErrorType.HTTP_ERROR);
     }
 
@@ -98,11 +101,13 @@ export class ErrorData extends EventData implements IErrorData {
         let status = getMsg(context, STATUS);
         let responseText = getMsg(context, RESPONSE_TEXT);
         let responseXML = getMsg(context, RESPONSE_XML);
+
+
         return new ErrorData(source, errorName, errorMessage, responseText, responseXML, errorCode + EMPTY_STR, status, errorType);
     }
 
     private static getMsg(context, param) {
-        return getMessage(context.getIf(param).orElse(UNKNOWN).value);
+        return getMessage(context.getIf(param).orElse(EMPTY_STR).value);
     }
 
     static fromServerError(context: Config): ErrorData {

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

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import {Config, DQ} from "mona-dish";
-import {BEGIN, CTX_PARAM_PASS_THR, EVENT, P_PARTIAL_SOURCE, SOURCE} from "../core/Const";
+import {BEGIN, CTX_PARAM_REQ_PASS_THR, EVENT, P_PARTIAL_SOURCE, SOURCE} from "../core/Const";
 
 export class EventData implements IEventData{
     type: string;
@@ -33,7 +33,7 @@ export class EventData implements IEventData{
 
         let sourceId: string = context.getIf(SOURCE)
             .orElseLazy(() => context.getIf(P_PARTIAL_SOURCE).value)
-            .orElseLazy(() => context.getIf(CTX_PARAM_PASS_THR, P_PARTIAL_SOURCE).value)
+            .orElseLazy(() => context.getIf(CTX_PARAM_REQ_PASS_THR, P_PARTIAL_SOURCE).value)
             .value;
         if (sourceId) {
             eventData.source = DQ.byId(sourceId, true).first().value.value;