jsf.js_next_gen 4.0.1-alpha.0 → 4.0.1-beta.2

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

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-import {AsyncRunnable, IAsyncRunnable} from "../util/AsyncRunnable";
-import {Config, DQ} from "mona-dish";
+import {AsyncRunnable} from "../util/AsyncRunnable";
+import {Config, DQ, DQ$, Stream} 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, CTX_PARAM_SRC_FRM_ID, CTX_PARAM_SRC_CTL_ID, CTX_PARAM_PPS
+    VAL_AJAX, IDENT_NONE
 } from "../core/Const";
 import {
     resolveFinalUrl,
@@ -54,10 +54,6 @@ 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
@@ -66,43 +62,60 @@ import {ExtConfig} from "../util/ExtDomQuery";
  *
  */
 
-export class XhrRequest extends AsyncRunnable<XMLHttpRequest> {
+export class XhrRequest implements 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
-     * @param internalContext internal context with internal info which is passed through, not used by the user
+     *
      * 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
      * @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 contentType = URL_ENCODED,
+        private xhrObject = new XMLHttpRequest()
     ) {
-        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(): IAsyncRunnable<XMLHttpRequest> {
+    start(): AsyncRunnable<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);
@@ -117,20 +130,15 @@ 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 partialIdsArray = this.internalContext.getIf(CTX_PARAM_PPS).value === true ? executes : [];
-            const formData: XhrFormData = new XhrFormData(
-                sourceForm,
-                resoveNamingContainerMapper(this.internalContext),
-                executes, partialIdsArray
-            );
+            // anyway TODO reimplement the partial ids array, we still do not have it in jsf the way we need it
+            let formData: XhrFormData = new XhrFormData(this.sourceForm, resoveNamingContainerMapper(this.internalContext), executesArr(), this.partialIdsArray);
 
             this.contentType = formData.isMultipartRequest ? "undefined" : this.contentType;
 
             // next step the pass through parameters are merged in for post params
             this.requestContext.$nspEnabled = false;
-            const requestContext = this.requestContext;
-            const requestPassThroughParams = requestContext.getIf(CTX_PARAM_REQ_PASS_THR) as ExtConfig;
+            let requestContext = this.requestContext;
+            let requestPassThroughParams = requestContext.getIf(CTX_PARAM_REQ_PASS_THR) as ExtConfig;
 
             // we are turning off here the jsf, faces remapping because we are now dealing with
             // pass-through parameters
@@ -141,9 +149,6 @@ export class XhrRequest extends 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;
             }
@@ -151,15 +156,15 @@ export class XhrRequest extends AsyncRunnable<XMLHttpRequest> {
             this.responseContext = requestPassThroughParams.deepCopy;
 
             // we have to shift the internal passthroughs around to build up our response context
-            const responseContext = this.responseContext;
+            let 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(sourceForm, formData, this.ajaxType), true);
+            xhrObject.open(this.ajaxType, resolveFinalUrl(this.sourceForm, formData, this.ajaxType), true);
 
             // adding timeout
             this.timeout ? xhrObject.timeout = this.timeout : null;
@@ -189,15 +194,40 @@ export class XhrRequest extends 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
@@ -207,7 +237,7 @@ export class XhrRequest extends AsyncRunnable<XMLHttpRequest> {
      * @param reject
      */
     private registerXhrCallbacks(resolve: Consumer<any>, reject: Consumer<any>) {
-        const xhrObject = this.xhrObject;
+        let xhrObject = this.xhrObject;
 
         xhrObject.onabort = () => {
             this.onAbort(reject);
@@ -223,17 +253,13 @@ export class XhrRequest extends AsyncRunnable<XMLHttpRequest> {
         };
         xhrObject.onerror = (errorData: any) => {
 
-            // some browsers trigger an error when cancelling a request internally, or when
-            // cancel is called from outside
+            // some browsers trigger an error when cancelling a request internally
             // in this case we simply ignore the request and clear up the queue, because
             // it is not safe anymore to proceed with the current queue
             // This bypasses a Safari issue where it keeps requests hanging after page unload
             // and then triggers a cancel error on then instead of just stopping
             // and clearing the code
             if(this.isCancelledResponse(this.xhrObject)) {
-                /*
-                 * this triggers the catch chain and after that finally
-                 */
                 reject();
                 this.stopProgress = true;
                 return;
@@ -281,12 +307,14 @@ export class XhrRequest extends AsyncRunnable<XMLHttpRequest> {
 
     private handleMalFormedXML(resolve: Function) {
         this.stopProgress = true;
-        const errorData = {
+        let errorData = {
             type: ERROR,
             status: MALFORMEDXML,
             responseCode: 200,
             responseText: this.xhrObject?.responseText,
-            source:  this.internalContext.getIf(CTX_PARAM_SRC_CTL_ID).value
+            // we remap the element just in case it gets replaced
+            // it will be unremapped
+            source:  this.source.id.value
         };
         try {
             this.handleError(errorData, true);
@@ -303,22 +331,16 @@ export class XhrRequest extends 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) {
-        const isPost = this.ajaxType != REQ_TYPE_GET;
+        let 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);
@@ -332,7 +354,7 @@ export class XhrRequest extends AsyncRunnable<XMLHttpRequest> {
      * other helpers
      */
     private sendEvent(evtType: string) {
-        const eventData = EventData.createFromRequest(this.xhrObject, this.requestContext, evtType);
+        let eventData = EventData.createFromRequest(this.xhrObject, this.requestContext, evtType);
         try {
             // User code error, we might cover
             // this in onError, but also we cannot swallow it.
@@ -344,15 +366,14 @@ export class XhrRequest extends AsyncRunnable<XMLHttpRequest> {
         } catch (e) {
             e.source = e?.source ?? this.requestContext.getIf(SOURCE).value;
             this.handleError(e);
-
             throw e;
         }
     }
 
     private handleError(exception, responseFormatError: boolean = false) {
-        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 errorData = (responseFormatError) ? ErrorData.fromHttpConnection(exception.source, exception.type, exception.status, exception.responseText, exception.responseCode, exception.status) : ErrorData.fromClient(exception);
 
+        let eventHandler = resolveHandlerFunc(this.requestContext, this.responseContext, ON_ERROR);
         Implementation.sendError(errorData, eventHandler);
     }
 }

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

@@ -14,8 +14,7 @@
  * limitations under the License.
  */
 
-import {DQ} from "mona-dish";
-import {ExtLang} from "../impl/util/Lang";
+import {DQ, Stream} from "mona-dish";
 
 /**
  * legacy code to enable various aspects
@@ -29,7 +28,6 @@ import {ExtLang} from "../impl/util/Lang";
  * 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
@@ -88,8 +86,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: Array<[string, any]> = Array.isArray(params) ? [...params] : ofAssoc(params);
-        paramsStream.forEach(([key, data]) => myfaces.oam.setHiddenInput(formName, key, data));
+        let paramsStream: Stream<[string, any]> = Array.isArray(params) ? Stream.of(...params) : Stream.ofAssoc(params);
+        paramsStream.each(([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 ?? '');
@@ -104,6 +102,8 @@ 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.forEach(([key, data]) => {
+                paramsStream.each(([key, data]) => {
                     myfaces.oam.clearHiddenInput(formName, key);
                 });
                 myfaces.oam.clearHiddenInput(formName, `${formName}:_idcl`);