jsf.js_next_gen 4.0.0-beta-23 → 4.0.1-alpha.0

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

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-import {AsyncRunnable} from "../util/AsyncRunnable";
-import {Config, DQ, Stream} from "mona-dish";
+import {AsyncRunnable, IAsyncRunnable} from "../util/AsyncRunnable";
+import {Config, DQ} 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,145 +37,151 @@ 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, CTX_PARAM_SRC_FRM_ID, CTX_PARAM_SRC_CTL_ID, CTX_PARAM_PPS
 } 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
+ * This means from the outside the
+ * xhr request is similar to a Promise in a way
+ * that you can add then and catch and finally callbacks.
+ *
  *
  * 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> {
+export class XhrRequest extends AsyncRunnable<XMLHttpRequest> {
 
     private responseContext: Config;
 
     private stopProgress = false;
 
-    /**
-     * helper support so that we do not have to drag in Promise shims
-     */
-    private catchFuncs: Array<Function> = [];
-    private thenFunc: Array<Function> = [];
 
+    private xhrObject = new XMLHttpRequest();
     /**
-     * Reqired 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
-     *
-     * Optional Parameters
+     * Required Parameters
      *
+     * @param requestContext the request context with all pass through values
      * @param internalContext internal context with internal info which is passed through, not used by the user
-     * @param partialIdsArray an optional restricting partial ids array for encoding
+     * Optional Parameters
      * @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
      */
     constructor(
-        private source: DQ,
-        private sourceForm: DQ,
-        private requestContext: Config,
+        private requestContext: ExtConfig,
         private internalContext: Config,
-        private partialIdsArray = [],
         private timeout = NO_TIMEOUT,
         private ajaxType = REQ_TYPE_POST,
-        private contentType = URL_ENCODED,
-        private xhrObject = new XMLHttpRequest()
+        private contentType = URL_ENCODED
     ) {
-        /*
-        * we omit promises here
-        * some browsers do not support it and we do not need shim code
-        */
-        this.registerXhrCallbacks((data: any) => {
-            this.resolve(data)
-        }, (data: any) => {
-            this.reject(data)
-        });
+        super();
+        // 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) => this.reject(data));
     }
 
-    start(): 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_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
+            const executes = executesArr();
+            const partialIdsArray = this.internalContext.getIf(CTX_PARAM_PPS).value === true ? executes : [];
+            const formData: XhrFormData = new XhrFormData(
+                sourceForm,
+                resoveNamingContainerMapper(this.internalContext),
+                executes, partialIdsArray
+            );
 
             this.contentType = formData.isMultipartRequest ? "undefined" : this.contentType;
 
-            //next step the pass through parameters are merged in for post params
-            let requestContext = this.requestContext;
-            let passThroughParams = requestContext.getIf(CTX_PARAM_PASS_THR);
+            // next step the pass through parameters are merged in for post params
+            this.requestContext.$nspEnabled = false;
+            const requestContext = this.requestContext;
+            const 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 {
+                // unfortunately as long as we support
+                // both namespaces we have to keep manual control
+                // on the key renaming before doing ops like deep copy
+                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
-            let responseContext = this.responseContext;
+            // we have to shift the internal passthroughs around to build up our response context
+            const 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);
+            xhrObject.open(this.ajaxType, resolveFinalUrl(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;
@@ -182,41 +189,15 @@ export class XhrRequest implements AsyncRunnable<XMLHttpRequest> {
 
     cancel() {
         try {
+            // this causes onError to be called where the error
+            // handling takes over
             this.xhrObject.abort();
         } catch (e) {
             this.handleError(e);
         }
     }
 
-    resolve(data: any) {
-        Stream.of(...this.thenFunc).reduce((inputVal: any, thenFunc: any) => {
-            return thenFunc(inputVal);
-        }, data);
-    }
 
-    reject(data: any) {
-        Stream.of(...this.catchFuncs).reduce((inputVal: any, catchFunc: any) => {
-            return catchFunc(inputVal);
-        }, data);
-    }
-
-    catch(func: (data: any) => any): AsyncRunnable<XMLHttpRequest> {
-        this.catchFuncs.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);
-        return this;
-    }
-
-    then(func: (data: any) => any): AsyncRunnable<XMLHttpRequest> {
-        //this.$promise.then(func);
-        this.thenFunc.push(func);
-        return this;
-    }
 
     /**
      * attaches the internal event and processing
@@ -226,7 +207,7 @@ export class XhrRequest implements AsyncRunnable<XMLHttpRequest> {
      * @param reject
      */
     private registerXhrCallbacks(resolve: Consumer<any>, reject: Consumer<any>) {
-        let xhrObject = this.xhrObject;
+        const xhrObject = this.xhrObject;
 
         xhrObject.onabort = () => {
             this.onAbort(reject);
@@ -241,14 +222,18 @@ 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
+
+            // some browsers trigger an error when cancelling a request internally, or when
+            // cancel is called from outside
             // 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
             if(this.isCancelledResponse(this.xhrObject)) {
+                /*
+                 * this triggers the catch chain and after that finally
+                 */
                 reject();
                 this.stopProgress = true;
                 return;
@@ -258,7 +243,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,25 +269,24 @@ 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) {
         this.stopProgress = true;
-        let errorData = {
+        const errorData = {
             type: ERROR,
             status: MALFORMEDXML,
             responseCode: 200,
             responseText: this.xhrObject?.responseText,
-            source: {
-                id: this.source.id.value
-            }
+            source:  this.internalContext.getIf(CTX_PARAM_SRC_CTL_ID).value
         };
         try {
             this.handleError(errorData, true);
@@ -311,7 +295,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>) {
@@ -319,21 +303,27 @@ export class XhrRequest implements AsyncRunnable<XMLHttpRequest> {
         if (this.stopProgress) {
             return;
         }
+        /**
+         * now call the then chain
+         */
         resolve(data);
     }
 
     private onError(errorData: any,  reject: Consumer<any>) {
         this.handleError(errorData);
+        /*
+         * this triggers the catch chain and after that finally
+         */
         reject();
     }
 
     private sendRequest(formData: XhrFormData) {
-        let isPost = this.ajaxType != REQ_TYPE_GET;
+        const 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);
         }
     }
@@ -342,26 +332,27 @@ export class XhrRequest implements AsyncRunnable<XMLHttpRequest> {
      * other helpers
      */
     private sendEvent(evtType: string) {
-        let eventData = EventData.createFromRequest(this.xhrObject, this.requestContext, evtType);
+        const 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;
         }
     }
 
     private handleError(exception, responseFormatError: boolean = false) {
-        let errorData = (responseFormatError) ? ErrorData.fromHttpConnection(exception.source, exception.type, exception.status, exception.responseText, exception.responseCode, exception.status) : ErrorData.fromClient(exception);
+        const errorData = (responseFormatError) ? ErrorData.fromHttpConnection(exception.source, exception.type, exception.status, exception.responseText, exception.responseCode, exception.status) : ErrorData.fromClient(exception);
+        const eventHandler = resolveHandlerFunc(this.requestContext, this.responseContext, ON_ERROR);
 
-        let eventHandler = resolveHandlerFunc(this.requestContext, this.responseContext, ON_ERROR);
         Implementation.sendError(errorData, eventHandler);
     }
-
 }

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

@@ -14,7 +14,8 @@
  * limitations under the License.
  */
 
-import {DQ, Stream} from "mona-dish";
+import {DQ} from "mona-dish";
+import {ExtLang} from "../impl/util/Lang";
 
 /**
  * legacy code to enable various aspects
@@ -28,6 +29,7 @@ import {DQ, Stream} from "mona-dish";
  * we might move the code over in the future, but for now a straight 1:1 port suffices
  */
 export module oam {
+    import ofAssoc = ExtLang.ofAssoc;
     /**
      * sets a hidden input field
      * @param formName the formName
@@ -62,18 +64,23 @@ export module oam {
         DQ.byId(element).delete();
     };
 
-    // noinspection JSUnusedGlobalSymbols
+    // noinspection JSUnusedGlobalSymbols,JSUnusedLocalSymbols
     /**
      * does special form submit remapping
      * re-maps the issuing command link into something,
-     * a decode of the command link on the server can understand
+     * the "decode" of the command link on the server can understand
      *
      * @param formName
      * @param linkId
      * @param target
      * @param params
      */
-    export const submitForm = function (formName: string, linkId: string, target: string, params: { [key: string]: any }): boolean {
+    export const submitForm = function (formName: string, linkId: string | null = null, target: string |null = null, params: AssocArr<any> | Tuples<string, any> | null = {} ): boolean {
+
+
+        //handle a possible incoming null, not sure if this is used that way anywhere, but we allow it
+        params = (!params) ? {} : params;
+
         let clearFn = 'clearFormHiddenParams_' + formName.replace(/-/g, '\$:').replace(/:/g, '_');
         window?.[clearFn]?.(formName);
 
@@ -81,18 +88,21 @@ export module oam {
         if (window?.myfaces?.core?.config?.autoScroll && (window as any)?.getScrolling) {
             myfaces.oam.setHiddenInput(formName, 'autoScroll', (window as any)?.getScrolling());
         }
-        Stream.ofAssoc(params).each((param: [string, any]) => {
-            myfaces.oam.setHiddenInput(formName, param[0], param[1]);
-        });
+        let paramsStream: Array<[string, any]> = Array.isArray(params) ? [...params] : ofAssoc(params);
+        paramsStream.forEach(([key, data]) => myfaces.oam.setHiddenInput(formName, key, data));
 
         //we call the namespaced function, to allow decoration, via a direct call we would
-        myfaces.oam.setHiddenInput(formName, `${formName}:_idcl`, linkId);
+        myfaces.oam.setHiddenInput(formName, `${formName}:_idcl`, linkId ?? '');
+
 
-        DQ.byId(document.forms[formName]).each(form => {
+        DQ.byId(document.forms?.[formName] ?? document.getElementById(formName)).each(form => {
             const ATTR_TARGET = "target";
             const formElement = form.getAsElem(0).value as HTMLFormElement;
-            const oldTarget = form.attr(ATTR_TARGET).value;
-            form.attr(ATTR_TARGET).value = target;
+            const oldTarget = (form.getAsElem(0).value as HTMLFormElement).getAttribute("target");
+
+            if(target != "null" && target) {
+                (form.getAsElem(0).value as HTMLFormElement).setAttribute("target", target);
+            }
 
             const result = formElement?.onsubmit?.(null);
 
@@ -103,9 +113,15 @@ export module oam {
             } catch (e) {
                 window?.console.error(e);
             } finally {
-                form.attr(ATTR_TARGET).value = oldTarget;
-                Stream.ofAssoc(params).each((param: [string, any]) => {
-                    myfaces.oam.clearHiddenInput(formName, param[0]);
+                if(oldTarget == null || oldTarget == "null") {
+                    (form.getAsElem(0).value as HTMLFormElement).removeAttribute("target");
+                } else {
+                    (form.getAsElem(0).value as HTMLFormElement).setAttribute("target", oldTarget);
+                }
+
+                // noinspection JSUnusedLocalSymbols
+                paramsStream.forEach(([key, data]) => {
+                    myfaces.oam.clearHiddenInput(formName, key);
                 });
                 myfaces.oam.clearHiddenInput(formName, `${formName}:_idcl`);
             }