jsf.js_next_gen 4.0.1-beta.1 → 4.0.1-beta.3

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

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-import {AsyncRunnable} from "../util/AsyncRunnable";
-import {Config, DQ, 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";
@@ -41,7 +41,7 @@ import {
     STATE_EVT_TIMEOUT,
     STD_ACCEPT,
     URL_ENCODED,
-    VAL_AJAX, IDENT_NONE
+    VAL_AJAX, IDENT_NONE, CTX_PARAM_SRC_FRM_ID, CTX_PARAM_SRC_CTL_ID, CTX_PARAM_PPS
 } from "../core/Const";
 import {
     resolveFinalUrl,
@@ -54,6 +54,10 @@ import {ExtConfig} from "../util/ExtDomQuery";
 /**
  * Faces XHR Request Wrapper
  * 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
@@ -62,60 +66,43 @@ import {ExtConfig} from "../util/ExtDomQuery";
  *
  */
 
-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 catchFunctions: Array<Function> = [];
-    private thenFunctions: Array<Function> = [];
 
+    private xhrObject = new XMLHttpRequest();
     /**
      * 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
-     *
-     * Optional Parameters
-     *
      * @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 fulfill the XMLHTTPRequest api, default XMLHttpRequest
      */
     constructor(
-        private source: DQ,
-        private sourceForm: DQ,
         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
     ) {
-
+        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)
-        });
+        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_REQ_PASS_THR, P_EXECUTE).get(IDENT_NONE).value.split(/\s+/gi);
@@ -130,15 +117,20 @@ export class XhrRequest implements 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
-            // 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);
+            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
             this.requestContext.$nspEnabled = false;
-            let requestContext = this.requestContext;
-            let requestPassThroughParams = requestContext.getIf(CTX_PARAM_REQ_PASS_THR) as ExtConfig;
+            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
@@ -149,6 +141,9 @@ export class XhrRequest implements AsyncRunnable<XMLHttpRequest> {
             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;
             }
@@ -156,15 +151,15 @@ export class XhrRequest implements AsyncRunnable<XMLHttpRequest> {
             this.responseContext = requestPassThroughParams.deepCopy;
 
             // we have to shift the internal passthroughs around to build up our response context
-            let responseContext = this.responseContext;
+            const responseContext = this.responseContext;
 
             responseContext.assign(CTX_PARAM_MF_INTERNAL).value = this.internalContext.value;
 
-            // per spec the onevent and onerror handlers 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
             this.timeout ? xhrObject.timeout = this.timeout : null;
@@ -194,40 +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.thenFunctions).reduce((inputVal: any, thenFunc: any) => {
-            return thenFunc(inputVal);
-        }, data);
-    }
 
-    reject(data: any) {
-        Stream.of(...this.catchFunctions).reduce((inputVal: any, catchFunc: any) => {
-            return catchFunc(inputVal);
-        }, data);
-    }
-
-    catch(func: (data: any) => any): AsyncRunnable<XMLHttpRequest> {
-        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.catchFunctions.push(func);
-        this.thenFunctions.push(func);
-        return this;
-    }
-
-    then(func: (data: any) => any): AsyncRunnable<XMLHttpRequest> {
-        this.thenFunctions.push(func);
-        return this;
-    }
 
     /**
      * attaches the internal event and processing
@@ -237,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);
@@ -253,13 +223,17 @@ export class XhrRequest implements AsyncRunnable<XMLHttpRequest> {
         };
         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;
@@ -307,14 +281,12 @@ export class XhrRequest implements AsyncRunnable<XMLHttpRequest> {
 
     private handleMalFormedXML(resolve: Function) {
         this.stopProgress = true;
-        let errorData = {
+        const errorData = {
             type: ERROR,
             status: MALFORMEDXML,
             responseCode: 200,
             responseText: this.xhrObject?.responseText,
-            // we remap the element just in case it gets replaced
-            // it will be unremapped
-            source:  this.source.id.value
+            source:  this.internalContext.getIf(CTX_PARAM_SRC_CTL_ID).value
         };
         try {
             this.handleError(errorData, true);
@@ -331,16 +303,22 @@ 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
             this.xhrObject.send((isPost) ? formData.toFormData() : null);
@@ -354,7 +332,7 @@ 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.
@@ -366,14 +344,15 @@ export class XhrRequest implements AsyncRunnable<XMLHttpRequest> {
         } 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
@@ -86,8 +88,8 @@ export module oam {
         if (window?.myfaces?.core?.config?.autoScroll && (window as any)?.getScrolling) {
             myfaces.oam.setHiddenInput(formName, 'autoScroll', (window as any)?.getScrolling());
         }
-        let paramsStream: Stream<[string, any]> = Array.isArray(params) ? Stream.of(...params) : Stream.ofAssoc(params);
-        paramsStream.each(([key, data]) => myfaces.oam.setHiddenInput(formName, key, data));
+        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 ?? '');
@@ -102,8 +104,6 @@ export module oam {
                 (form.getAsElem(0).value as HTMLFormElement).setAttribute("target", target);
             }
 
-
-
             const result = formElement?.onsubmit?.(null);
 
             try {
@@ -120,7 +120,7 @@ export module oam {
                 }
 
                 // noinspection JSUnusedLocalSymbols
-                paramsStream.each(([key, data]) => {
+                paramsStream.forEach(([key, data]) => {
                     myfaces.oam.clearHiddenInput(formName, key);
                 });
                 myfaces.oam.clearHiddenInput(formName, `${formName}:_idcl`);