jsf.js_next_gen 4.1.0-beta.2 → 4.1.0-beta.21

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

@@ -25,8 +25,8 @@ const ofAssoc = ExtLang.ofAssoc;
 import {Es2019Array} from "mona-dish";
 
 
-type ParamsMapper<V, K> = (key: V, item: K) => [V, K];
-const defaultParamsMapper: ParamsMapper<string, any> = (key, item) => [key, item];
+type ParamsMapper = (key: string, value: any) => [string, any];
+const defaultParamsMapper: ParamsMapper = (key, item) => [key, item];
 
 /**
  * A unified form data class
@@ -59,56 +59,20 @@ export class XhrFormData extends Config {
      * @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, private paramsMapper: ParamsMapper<string, any> = defaultParamsMapper, executes?: string[], private partialIds?: string[]) {
+    constructor(dataSource: DQ, private paramsMapper: ParamsMapper = defaultParamsMapper, executes?: string[], partialIds?: string[]) {
         super({});
-        //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
+         * Spec. 13.3.1 — order matters: detect multipart first, encode fields second,
+         * apply view state last (so it is not double-counted if already present in fields).
          */
-        this.resolveRequestType(this.dataSource, executes);
-        this.encodeSubmittableFields(this.dataSource, this.partialIds);
-        this.applyViewState(this.dataSource);
+        this.initFormData(dataSource, executes, partialIds);
     }
 
     /**
      * @returns a Form data representation, this is needed for file submits
      */
     toFormData(): FormData {
-        /*
-           * expands key: [item1, item2]
-           * to: [{key: key,  value: item1}, {key: key, value: item2}]
-           */
-        let expandValueArrays = ([key, item]) => {
-            if (Array.isArray(item)) {
-                return new Es2019Array(...item).map(value => {
-                    return {key, value}
-                })
-            }
-            return [{key, value: item}]
-        }
-
-        /*
-         * remaps the incoming {key, value} tuples
-         * to naming container prefixed keys and values
-         */
-        let remapForNamingContainer = ({key, value}) => {
-            key = this.remapKeyForNamingContainer(key);
-            return {key, value}
-        };
-
-        /*
-         * collects everything into a FormData object
-         */
-        return ofAssoc(this.value)
-            .flatMap(expandValueArrays)
-            .map(remapForNamingContainer)
-            .reduce((formData: FormData, {key, value}: any) => {
-                formData.append(key, value);
-                return formData;
-            }, new FormData()) as FormData;
+        return this.buildFormData();
     }
 
     /**
@@ -121,13 +85,19 @@ export class XhrFormData extends Config {
     }
 
     /**
-     * generic post init code, for now, this performs some post assign data post-processing
-     * @param rootElement the root element which knows the request type (usually a form)
-     * @param executes the executable dom nodes which need to be processed into the form data, which we can send
-     * in our ajax request
+     * Drives the three-phase form data initialisation in the required order.
      */
-    private resolveRequestType(rootElement: DQ, executes?: Array<string>) {
-        if (!executes || executes.indexOf(IDENT_NONE) != -1) {
+    private initFormData(dataSource: DQ, executes?: string[], partialIds?: string[]): void {
+        this.detectMultipartRequest(dataSource, executes);
+        this.encodeSubmittableFields(dataSource, partialIds);
+        this.applyViewState(dataSource);
+    }
+
+    /**
+     * Sets isMultipartRequest when any of the executed elements is a file input.
+     */
+    private detectMultipartRequest(rootElement: DQ, executes?: Array<string>): void {
+        if (!executes || executes.includes(IDENT_NONE)) {
             return;
         }
         this.isMultipartRequest = rootElement.isMultipartCandidate(true);
@@ -138,12 +108,12 @@ export class XhrFormData extends Config {
      *
      * @param form the form holding the view state value
      */
-    private applyViewState(form: DQ) {
+    private applyViewState(form: DQ): void {
         if (this.getIf($nsp(P_VIEWSTATE)).isPresent()) {
             return;
         }
-        let viewStateElement = form.querySelectorAllDeep(`[name*='${$nsp(P_VIEWSTATE)}'`);
-        let viewState = viewStateElement.inputValue;
+        const viewStateElement = form.querySelectorAllDeep(`[name*='${$nsp(P_VIEWSTATE)}'`);
+        const viewState = viewStateElement.inputValue;
         this.appendIf(viewState.isPresent(), this.remapKeyForNamingContainer(viewStateElement.name.value)).value = viewState.value;
     }
 
@@ -152,24 +122,63 @@ export class XhrFormData extends Config {
      * @param {Node} parentItem - form element item is nested in
      * @param {Array} partialIds - ids fo PPS
      */
-    private encodeSubmittableFields(parentItem: DQ, partialIds: string[] = []) {
-
-        const mergeIntoThis = ([key, value]) => this.append(key).value = value;
-        const namingContainerRemap = ([key, value]) => this.paramsMapper(key as string, value);
+    private encodeSubmittableFields(parentItem: DQ, partialIds: string[] = []): void {
+        const mergeIntoThis = ([key, value]: [string, any]) => this.append(key).value = value;
+        const namingContainerRemap = ([key, value]: [string, any]) => this.paramsMapper(key as string, value);
 
-        const remappedPartialIds = partialIds.map(partialId => this.remapKeyForNamingContainer(partialId));
-        const partialIdsFilter = ([key, value]) => (!remappedPartialIds.length || key.indexOf("@") == 0) ? true :
-            remappedPartialIds.indexOf(key) != -1;
+        const remappedPartialIds = partialIds.map(id => this.remapKeyForNamingContainer(id));
 
-        let inputs = getFormInputsAsArr(parentItem);
-        inputs
+        getFormInputsAsArr(parentItem)
             .map(fixEmptyParameters)
             .map(namingContainerRemap)
-            .filter(partialIdsFilter)
+            .filter(([key]) => this.isFieldIncluded(key, remappedPartialIds))
             .forEach(mergeIntoThis);
     }
 
+    /**
+     * Returns true when the field should be included in the submission.
+     * Special "@"-prefixed keys (internal markers) are always included.
+     * When no partial ids are specified, everything passes through.
+     */
+    private isFieldIncluded(key: string, remappedPartialIds: string[]): boolean {
+        if (!remappedPartialIds.length || key.startsWith("@")) {
+            return true;
+        }
+        return remappedPartialIds.includes(key);
+    }
+
+    /**
+     * Builds the FormData object from the internal key→value[] map.
+     * Arrays are expanded so each value becomes a separate FormData entry.
+     */
+    private buildFormData(): FormData {
+        const expandValueArrays = ([key, item]: [string, any]) => {
+            if (Array.isArray(item)) {
+                return new Es2019Array(...item).map((value: any) => ({key, value}));
+            }
+            return [{key, value: item}];
+        };
+
+        const remapForNamingContainer = ({key, value}: {key: string, value: any}) => ({
+            key: this.remapKeyForNamingContainer(key),
+            value
+        });
+
+        return ofAssoc(this.value)
+            .flatMap(expandValueArrays)
+            .map(remapForNamingContainer)
+            .reduce((formData: FormData, {key, value}: any) => {
+                formData.append(key, value);
+                return formData;
+            }, new FormData()) as FormData;
+    }
+
+    /**
+     * Applies paramsMapper to remap only the key, ignoring the value transformation.
+     * EMPTY_STR is passed as a placeholder since only the remapped key is used.
+     */
     private remapKeyForNamingContainer(key: string): string {
-        return this.paramsMapper(key, "")[0];
+        const [remappedKey] = this.paramsMapper(key, EMPTY_STR); // value is a required arg but irrelevant here; only the remapped key is used
+        return remappedKey;
     }
 }

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

@@ -29,7 +29,6 @@ import {
     CONTENT_TYPE,
     CTX_PARAM_MF_INTERNAL,
     CTX_PARAM_REQ_PASS_THR,
-    ERROR,
     HEAD_FACES_REQ,
     MALFORMEDXML,
     NO_TIMEOUT,
@@ -87,16 +86,14 @@ import {ExtConfig} from "../util/ExtDomQuery";
 
 export class XhrRequest extends AsyncRunnable<XMLHttpRequest> {
 
-    private responseContext: Config;
-
-    private stopProgress = false;
-
-
-    private xhrObject = new XMLHttpRequest();
-
+    private readonly ERR_INVALID_RESPONSE = "Invalid Response";
+    private readonly ERR_EMPTY_RESPONSE = "Empty Response";
     static readonly TYPE_CHECKBOX = "checkbox";
     static readonly TYPE_RADIO = "radio";
 
+    private responseContext!: Config;
+    private stopProgress = false;
+    private xhrObject = new XMLHttpRequest();
 
     /**
      * Required Parameters
@@ -124,14 +121,9 @@ export class XhrRequest extends AsyncRunnable<XMLHttpRequest> {
 
     start(): IAsyncRunnable<XMLHttpRequest> {
 
-        let ignoreErr = failSaveExecute;
-        let xhrObject = this.xhrObject;
-        let sourceForm = DQ.byId(this.internalContext.getIf(CTX_PARAM_SRC_FRM_ID).value)
-
-
-        let executesArr = () => {
-            return this.requestContext.getIf(CTX_PARAM_REQ_PASS_THR, P_EXECUTE).get(IDENT_NONE).value.split(/\s+/gi);
-        };
+        const ignoreErr = failSaveExecute;
+        const xhrObject = this.xhrObject;
+        const sourceForm = DQ.byId(this.internalContext.getIf(CTX_PARAM_SRC_FRM_ID).value);
 
         try {
             // encoded we need to decode
@@ -142,7 +134,7 @@ export class XhrRequest extends AsyncRunnable<XMLHttpRequest> {
             // 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
-            const executes = executesArr();
+            const executes = this.requestContext.getIf(CTX_PARAM_REQ_PASS_THR, P_EXECUTE).get(IDENT_NONE).value.split(/\s+/gi);
             const partialIdsArray = this.internalContext.getIf(CTX_PARAM_PPS).value === true ? executes : [];
             const formData: XhrFormData = new XhrFormData(
                 sourceForm,
@@ -150,8 +142,6 @@ export class XhrRequest extends AsyncRunnable<XMLHttpRequest> {
                 executes, partialIdsArray
             );
 
-            this.contentType = formData.isMultipartRequest ? "undefined" : this.contentType;
-
             // next step the pass through parameters are merged in for post params
             this.requestContext.$nspEnabled = false;
             const requestContext = this.requestContext;
@@ -188,21 +178,17 @@ export class XhrRequest extends AsyncRunnable<XMLHttpRequest> {
 
             xhrObject.open(this.ajaxType, resolveFinalUrl(sourceForm, formData, this.ajaxType), true);
 
-            // adding timeout
-            this.timeout ? xhrObject.timeout = this.timeout : null;
+            if (this.timeout) xhrObject.timeout = this.timeout;
 
             // 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") {
+            if (!formData.isMultipartRequest) {
                 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
-            // setting, they accept headers automatically
+            // some webkit based mobile browsers do not follow the w3c spec for Accept headers
             ignoreErr(() => xhrObject.setRequestHeader(REQ_ACCEPT, STD_ACCEPT));
 
             this.sendEvent(BEGIN);
@@ -216,8 +202,6 @@ export class XhrRequest extends AsyncRunnable<XMLHttpRequest> {
         return this;
     }
 
-
-
     cancel() {
         try {
             // this causes onError to be called where the error
@@ -252,46 +236,12 @@ export class XhrRequest extends AsyncRunnable<XMLHttpRequest> {
             this.onResponseProcessed(this.xhrObject, resolve);
         };
 
-        if(xhrObject?.upload) {
-            //this is an  extension so that we can send the upload object of the current
-            //request before any operation
-            this.internalContext.getIf(CTX_PARAM_UPLOAD_PREINIT).value?.(xhrObject.upload);
-            //now we hook in the upload events
-            xhrObject.upload.addEventListener("progress", (event: ProgressEvent) => {
-                this.internalContext.getIf(CTX_PARAM_UPLOAD_ON_PROGRESS).value?.(xhrObject.upload, event);
-            });
-            xhrObject.upload.addEventListener("load", (event: ProgressEvent) => {
-                this.internalContext.getIf(CTX_PARAM_UPLOAD_LOAD).value?.(xhrObject.upload, event);
-            });
-            xhrObject.upload.addEventListener("loadstart", (event: ProgressEvent) => {
-                this.internalContext.getIf(CTX_PARAM_UPLOAD_LOADSTART).value?.(xhrObject.upload, event);
-            });
-            xhrObject.upload.addEventListener("loadend", (event: ProgressEvent) => {
-                this.internalContext.getIf(CTX_PARAM_UPLOAD_LOADEND).value?.(xhrObject.upload, event);
-            });
-            xhrObject.upload.addEventListener("abort", (event: ProgressEvent) => {
-                this.internalContext.getIf(CTX_PARAM_UPLOAD_ABORT).value?.(xhrObject.upload, event);
-            });
-            xhrObject.upload.addEventListener("timeout", (event: ProgressEvent) => {
-                this.internalContext.getIf(CTX_PARAM_UPLOAD_TIMEOUT).value?.(xhrObject.upload, event);
-            });
-            xhrObject.upload.addEventListener("error", (event: ProgressEvent) => {
-                this.internalContext.getIf(CTX_PARAM_UPLOAD_ERROR).value?.(xhrObject.upload, event);
-            });
-
-        }
+        this.registerUploadCallbacks(xhrObject);
 
         xhrObject.onerror = (errorData: any) => {
-            // Safari in rare cases triggers an error when cancelling a request internally, or when
-            // 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
-            // in a page unload case it is safe to clear the queue
-            // in the exact safari case any request after this one in the queue is invalid
-            // because the queue references xhr requests to a page which already is gone!
+            // Older Safari/WebKit and Chrome/Chromium versions can cancel XHRs during
+            // navigation or download handoff by triggering onerror with status=0/readyState=4.
+            // Treat that as queue cleanup rather than reporting a user-facing Ajax error.
             if (this.isCancelledResponse(this.xhrObject)) {
                 /*
                  * this triggers the catch chain and after that finally
@@ -308,6 +258,35 @@ export class XhrRequest extends AsyncRunnable<XMLHttpRequest> {
         };
     }
 
+    private registerUploadCallbacks(xhrObject: XMLHttpRequest): void {
+        if (!xhrObject?.upload) {
+            return;
+        }
+        // fire the pre-init hook so callers can inspect the upload object before any transfer starts
+        this.internalContext.getIf(CTX_PARAM_UPLOAD_PREINIT).value?.(xhrObject.upload);
+        xhrObject.upload.addEventListener("progress", (event: ProgressEvent) => {
+            this.internalContext.getIf(CTX_PARAM_UPLOAD_ON_PROGRESS).value?.(xhrObject.upload, event);
+        });
+        xhrObject.upload.addEventListener("load", (event: ProgressEvent) => {
+            this.internalContext.getIf(CTX_PARAM_UPLOAD_LOAD).value?.(xhrObject.upload, event);
+        });
+        xhrObject.upload.addEventListener("loadstart", (event: ProgressEvent) => {
+            this.internalContext.getIf(CTX_PARAM_UPLOAD_LOADSTART).value?.(xhrObject.upload, event);
+        });
+        xhrObject.upload.addEventListener("loadend", (event: ProgressEvent) => {
+            this.internalContext.getIf(CTX_PARAM_UPLOAD_LOADEND).value?.(xhrObject.upload, event);
+        });
+        xhrObject.upload.addEventListener("abort", (event: ProgressEvent) => {
+            this.internalContext.getIf(CTX_PARAM_UPLOAD_ABORT).value?.(xhrObject.upload, event);
+        });
+        xhrObject.upload.addEventListener("timeout", (event: ProgressEvent) => {
+            this.internalContext.getIf(CTX_PARAM_UPLOAD_TIMEOUT).value?.(xhrObject.upload, event);
+        });
+        xhrObject.upload.addEventListener("error", (event: ProgressEvent) => {
+            this.internalContext.getIf(CTX_PARAM_UPLOAD_ERROR).value?.(xhrObject.upload, event);
+        });
+    }
+
     private isCancelledResponse(currentTarget: XMLHttpRequest): boolean {
         return currentTarget?.status === 0 && // cancelled internally by browser
             currentTarget?.readyState === 4 &&
@@ -321,30 +300,11 @@ export class XhrRequest extends AsyncRunnable<XMLHttpRequest> {
      * Those methods are the callbacks called by
      * the xhr object depending on its own state
      */
-    /**
-     * client side abort... also here for now we clean the queue
-     *
-     * @param resolve
-     * @param reject
-     * @private
-     */
-    private onAbort(resolve: Consumer<any>, reject: Consumer<any>) {
-        // reject means clear queue, in this case we abort entirely the processing
-        // does not happen yet, we have to probably rethink this strategy in the future
-        // when we introduce cancel functionality
+    private onAbort(_resolve: Consumer<any>, reject: Consumer<any>) {
         this.handleHttpError(reject);
     }
 
-    /**
-     * request timeout, this must be handled like a generic server error per spec
-     * unfortunately, so we have to jump to the next item (we cancelled before)
-     * @param resolve
-     * @param reject
-     * @private
-     */
-    private onTimeout(resolve: Consumer<any>, reject: Consumer<any>) {
-        // timeout also means we we probably should clear the queue,
-        // the state is unsafe for the next requests
+    private onTimeout(resolve: Consumer<any>, _reject: Consumer<any>) {
         this.sendEvent(STATE_EVT_TIMEOUT);
         this.handleHttpError(resolve);
     }
@@ -368,29 +328,28 @@ export class XhrRequest extends AsyncRunnable<XMLHttpRequest> {
     }
 
     private processRequestErrors(resolve: Consumer<any>): boolean {
-        const responseXML = new XMLQuery(this.xhrObject?.responseXML);
+        const responseXML = new XMLQuery(this.xhrObject?.responseXML as any);
         const responseText = this.xhrObject?.responseText ?? "";
         const responseCode = this.xhrObject?.status ?? -1;
+
+        // HTTP status takes priority: a non-2xx response is always an HTTP error,
+        // regardless of what the body contains (e.g. an HTML error page from a 404
+        // must not be misreported as malformedXML).
+        if (responseCode >= 300 || responseCode < 200) {
+            this.handleHttpError(resolve);
+            return true;
+        }
         if(responseXML.isXMLParserError()) {
             // Firefox: malformed XML produces a Document with <parsererror>
-            const errorName = "Invalid Response";
-            const errorMessage = "The response xml is invalid";
-            this.handleGenericResponseError(errorName, errorMessage, MALFORMEDXML, resolve);
+            this.handleGenericResponseError(this.ERR_INVALID_RESPONSE, "The response xml is invalid", MALFORMEDXML, resolve);
             return true;
         } else if(responseXML.isAbsent() && responseText.trim().length > 0) {
             // Chrome: responseXML is null for unparseable XML, but responseText has content
-            const errorName = "Invalid Response";
-            const errorMessage = "The response xml is invalid";
-            this.handleGenericResponseError(errorName, errorMessage, MALFORMEDXML, resolve);
+            this.handleGenericResponseError(this.ERR_INVALID_RESPONSE, "The response xml is invalid", MALFORMEDXML, resolve);
             return true;
         } else if(responseXML.isAbsent()) {
             // Truly empty response
-            const errorName = "Empty Response";
-            const errorMessage = "The response has provided no data";
-            this.handleGenericResponseError(errorName, errorMessage, EMPTY_RESPONSE, resolve);
-            return true;
-        } else if (responseCode >= 300  || responseCode < 200) {
-            this.handleHttpError(resolve);
+            this.handleGenericResponseError(this.ERR_EMPTY_RESPONSE, "The response has provided no data", EMPTY_RESPONSE, resolve);
             return true;
         }
         return false;
@@ -398,7 +357,7 @@ export class XhrRequest extends AsyncRunnable<XMLHttpRequest> {
 
 
     private handleGenericResponseError(errorName: string, errorMessage: string, responseStatus: string, resolve: (s?: any) => void) {
-        const errorData: ErrorData = new ErrorData(
+        const errorData = new ErrorData(
             this.internalContext.getIf(CTX_PARAM_SRC_CTL_ID).value,
             errorName, errorMessage,
             this.xhrObject?.responseText ?? "",
@@ -409,7 +368,7 @@ export class XhrRequest extends AsyncRunnable<XMLHttpRequest> {
         this.finalizeError(errorData, resolve);
     }
 
-    private handleHttpError(resolveOrReject: Function, errorMessage: string = "Generic HTTP Serror") {
+    private handleHttpError(resolveOrReject: Consumer<any>, errorMessage: string = "Generic HTTP Error") {
         this.stopProgress = true;
 
         const errorData = new ErrorData(
@@ -423,7 +382,7 @@ export class XhrRequest extends AsyncRunnable<XMLHttpRequest> {
         this.finalizeError(errorData, resolveOrReject);
     }
 
-    private finalizeError(errorData: ErrorData, resolveOrReject: Function) {
+    private finalizeError(errorData: ErrorData, resolveOrReject: Consumer<any>) {
         try {
             this.handleError(errorData, true);
         } finally {
@@ -435,33 +394,18 @@ export class XhrRequest extends AsyncRunnable<XMLHttpRequest> {
         }
     }
 
-    /**
-     * last minute cleanup, the request now either is fully done
-     * or not by having had a cancel or error event be
-     * @param data
-     * @param resolve
-     * @private
-     */
     private onResponseProcessed(data: any, resolve: Consumer<any>) {
-        // if stop progress true, the cleanup already has been performed
-        if (this.stopProgress) {
-            return;
+        if (!this.stopProgress) {
+            resolve(data);
         }
-        /*
-         * normal case, cleanup == next item if possible
-         */
-        resolve(data);
     }
 
     private sendRequest(formData: XhrFormData) {
-        const isPost = this.ajaxType != REQ_TYPE_GET;
-        if (formData.isMultipartRequest) {
-            // 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
-            this.xhrObject.send((isPost) ? formData.toString() : null);
+        if (this.ajaxType === REQ_TYPE_GET) {
+            this.xhrObject.send(null);
+            return;
         }
+        this.xhrObject.send(formData.isMultipartRequest ? formData.toFormData() : formData.toString());
     }
 
     /*
@@ -474,7 +418,7 @@ export class XhrRequest extends AsyncRunnable<XMLHttpRequest> {
             // 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);
+            const eventHandler = resolveHandlerFunc(this.requestContext, this.responseContext, ON_EVENT);
             Implementation.sendEvent(eventData, eventHandler);
         } catch (e) {
             e.source = e?.source ?? this.requestContext.getIf(SOURCE).value;
@@ -485,25 +429,26 @@ export class XhrRequest extends AsyncRunnable<XMLHttpRequest> {
         }
     }
 
-    private handleErrorAndClearQueue(e, responseFormatError: boolean = false) {
+    private handleErrorAndClearQueue(e: any, responseFormatError: boolean = false) {
         this.handleError(e, responseFormatError);
         this.reject(e);
     }
 
-    private handleError(exception, responseFormatError: boolean = false) {
-        const errorData = (responseFormatError) ? ErrorData.fromHttpConnection(exception.source, exception.type, exception.message ?? EMPTY_STR, exception.responseText, exception.responseXML, exception.responseCode, exception.status) : ErrorData.fromClient(exception);
+    private handleError(exception: any, responseFormatError: boolean = false) {
+        const errorData = responseFormatError
+            ? ErrorData.fromHttpConnection(exception.source, exception.type, exception.message ?? EMPTY_STR, exception.responseText, exception.responseXML, exception.responseCode, exception.status)
+            : ErrorData.fromClient(exception);
         const eventHandler = resolveHandlerFunc(this.requestContext, this.responseContext, ON_ERROR);
-
         Implementation.sendError(errorData, eventHandler);
     }
 
     private appendIssuingItem(formData: XhrFormData) {
         const issuingItemId = this.internalContext.getIf(CTX_PARAM_SRC_CTL_ID).value;
 
-        //to avoid sideffects with buttons we only can append the issuing item if no behavior event is set
+        //to avoid side effects with buttons we only can append the issuing item if no behavior event is set
         //MYFACES-4679!
         const eventType = formData.getIf($nsp(P_BEHAVIOR_EVENT)).value?.[0] ?? null;
-        const isBehaviorEvent = (!!eventType) && eventType != 'click';
+        const isBehaviorEvent = !!eventType && eventType !== 'click';
 
         //not encoded
         if(issuingItemId && formData.getIf(issuingItemId).isAbsent() && !isBehaviorEvent) {
@@ -514,9 +459,10 @@ export class XhrRequest extends AsyncRunnable<XMLHttpRequest> {
 
             //Checkbox and radio only value pass if checked is set, otherwise they should not show
             //up at all, and if checked is set, they either can have a value or simply being boolean
-            if((type == XhrRequest.TYPE_CHECKBOX || type == XhrRequest.TYPE_RADIO) && !issuingItem.checked) {
+            const isCheckable = type === XhrRequest.TYPE_CHECKBOX || type === XhrRequest.TYPE_RADIO;
+            if (isCheckable && !issuingItem.checked) {
                 return;
-            } else if((type == XhrRequest.TYPE_CHECKBOX || type == XhrRequest.TYPE_RADIO)) {
+            } else if (isCheckable) {
                 arr.assign(issuingItemId).value = itemValue.orElse(true).value;
             } else if (itemValue.isPresent()) {
                 arr.assign(issuingItemId).value = itemValue.value;
@@ -525,4 +471,4 @@ export class XhrRequest extends AsyncRunnable<XMLHttpRequest> {
             formData.shallowMerge(arr, true, true);
         }
     }
-}
+}

package/src/main/typescript/mona_dish_shim.ts

@@ -24,10 +24,14 @@
  * Used via tsconfig paths (for tests/tsx). Webpack keeps its own alias to
  * index_core.ts for the reduced-core production bundle.
  *
+ * Points to dist/typescript/index_core so that TypeScript 6 with
+ * moduleResolution:bundler can find the .ts source (no .d.ts alongside the
+ * UMD bundles). Uses index_core to avoid the optional crypto-js dependency.
+ *
  * Both import styles work:
  *   import { Lang } from 'mona-dish'                    // named import
  *   import pkg from 'mona-dish'; const { Lang } = pkg   // default import
  */
-export * from "mona-dish/src/main/typescript/index";
-import * as _monaDish from "mona-dish/src/main/typescript/index";
+export * from "../../../node_modules/mona-dish/src/main/typescript/index_core";
+import * as _monaDish from "../../../node_modules/mona-dish/src/main/typescript/index_core";
 export default _monaDish;

package/src/main/typescript/myfaces/OamSubmit.ts

@@ -37,7 +37,8 @@ export namespace oam {
      * @param value the value to be rendered
      */
     export const setHiddenInput = function (formName: string, name: string, value: string): void {
-        DQ.byId(document.forms[formName])
+        const forms = document.forms as HTMLCollectionOf<HTMLFormElement> & {[key: string]: HTMLFormElement};
+        DQ.byId(forms[formName])
             .each(form => {
                 const input = form.querySelectorAll(`input[type='hidden'][name='${name}']`);
                 if (input.isPresent()) {
@@ -57,7 +58,9 @@ export namespace oam {
      * @param name the name of the input field
      */
     export const clearHiddenInput = function (formName: string, name: string): void {
-        let element = document.forms?.[formName]?.elements?.[name];
+        const forms = document.forms as HTMLCollectionOf<HTMLFormElement> & {[key: string]: HTMLFormElement};
+        const elements = forms?.[formName]?.elements as HTMLFormControlsCollection & {[key: string]: Element};
+        let element = elements?.[name];
         if(!element) {
             return;
         }
@@ -75,7 +78,7 @@ export namespace oam {
      * @param target
      * @param params
      */
-    export const submitForm = function (formName: string, linkId: string | null = null, target: string |null = null, params: AssocArr<any> | Tuples<string, any> | null = {} ): boolean {
+    export const submitForm = function (formName: string, linkId: string | null = null, target: string |null = null, params: Record<string, any> | [string, any][] | null = {} ): boolean {
 
 
         //handle a possible incoming null, not sure if this is used that way anywhere, but we allow it
@@ -95,7 +98,8 @@ export namespace oam {
         myfaces.oam.setHiddenInput(formName, `${formName}:_idcl`, linkId ?? '');
 
 
-        DQ.byId(document.forms?.[formName] ?? document.getElementById(formName)).each(form => {
+        const forms = document.forms as HTMLCollectionOf<HTMLFormElement> & {[key: string]: HTMLFormElement};
+        DQ.byId(forms?.[formName] ?? document.getElementById(formName)).each(form => {
             const ATTR_TARGET = "target";
             const formElement = form.getAsElem(0).value as HTMLFormElement;
             const oldTarget = (form.getAsElem(0).value as HTMLFormElement).getAttribute("target");
@@ -104,7 +108,7 @@ export namespace oam {
                 (form.getAsElem(0).value as HTMLFormElement).setAttribute("target", target);
             }
 
-            const result = formElement?.onsubmit?.(null);
+            const result = formElement?.onsubmit?.(null as any);
 
             try {
                 if ((!!result) || 'undefined' == typeof result) {
@@ -129,4 +133,4 @@ export namespace oam {
         });
         return false;
     };
-}
+}