jsf.js_next_gen 1.0.0-beta-17 → 1.0.0-beta-18

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

@@ -13,11 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import {ArrayCollector, Config, DomQueryCollector, Lang, LazyStream} from "mona-dish";
-
-import {Stream, DQ} from "mona-dish";
+import {ArrayCollector, Config, DQ, Lang, LazyStream, Stream} from "mona-dish";
+import {EMPTY_STR, IDENT_ALL, IDENT_FORM, P_VIEWSTATE} from "../core/Const";
 import isString = Lang.isString;
-import {EMPTY_STR, P_VIEWSTATE} from "../core/Const";
 
 
 /**
@@ -28,43 +26,55 @@ import {EMPTY_STR, P_VIEWSTATE} from "../core/Const";
  * due to api constraints on the HTML Form object in IE11
  * and due to the url encoding constraint given by the jsf.js spec
  *
- * TODO not ideal. too many encoding calls
  * probably only one needed and one overlay!
- * the entire fileinput storing probably is redundant now
- * that domquery has been fixed
+ * the entire file input storing probably is redundant now
+ * that dom query has been fixed //TODO check this
  */
 export class XhrFormData extends Config {
-
-    private fileInputs = {};
+    /**
+     * Checks if the given datasource is a multipart request source
+     * multipart is only needed if one of the executes is a file input
+     * since file inputs are stateless, they fall out of the view state
+     * and need special handling. With file submits we have to send a formData object
+     * instead of an encoded string files cannot be sent that way
+     */
+    isMultipartRequest: boolean = false;
 
     /**
      * data collector from a given form
      *
      * @param dataSource either a form as DomQuery object or an encoded url string
-     * @param partialIdsArray partial ids to collect, to reduce the data sent down
+     * @param viewState the form view state or an external viewstate coming in as string
+     * @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 | string, private partialIdsArray?: string[]) {
+    constructor(private dataSource: DQ | string, viewState?: string, executes?: string[], private partialIds?: string[]) {
         super({});
         //a call to getViewState before must pass the encoded line
-        //a call from getViewState passes the form element as datasource
+        //a call from getViewState passes the form element as datasource,
         //so we have two call points
         if (isString(dataSource)) {
             this.assignEncodedString(<string>this.dataSource);
         } else {
-            this.handleFormSource();
+            this.applyFormDataToConfig();
+        }
+        if('undefined' != typeof viewState) {
+            this.assignEncodedString(viewState)
+        }
+        if(executes) {
+            this.postInit(...executes);
         }
     }
 
     /**
-     * generic application of ids
+     * generic post init code, for now, this peforms some post assign data post processing
      * @param executes
      */
-    applyFileInputs(...executes: Array<string>) {
-
+    postInit(...executes: Array<string>) {
         let fetchInput = (id: string): DQ => {
-            if (id == "@all") {
+            if (id == IDENT_ALL) {
                 return DQ.querySelectorAllDeep("input[type='file']");
-            } else if (id == "@form") {
+            } else if (id == IDENT_FORM) {
                 return (<DQ>this.dataSource).querySelectorAllDeep("input[type='file']");
             } else {
                 let element = DQ.byId(id, true);
@@ -76,48 +86,17 @@ export class XhrFormData extends Config {
             return item.isPresent();
         };
 
-        let applyInput = (item: DQ) => {
-            this.fileInputs[this.resolveSubmitIdentifier(<HTMLInputElement>item.getAsElem(0).value)] = true;
-        };
 
-        LazyStream.of(...executes)
+        this.isMultipartRequest = LazyStream.of(...executes)
             .map(fetchInput)
             .filter(inputExists)
-            .each(applyInput);
-    }
-
-    private getFileInputs(rootElment: DQ): DQ {
-        const rootFileInputs = rootElment
-            .filter(elem => elem.matchesSelector("input[type='file']"))
-        const childFileInputs = rootElment
-            .querySelectorAll("input[type='file']");
-
-        let ret = rootFileInputs.concat(childFileInputs);
-        return ret;
-    }
-
-    private handleFormSource() {
-        //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 javax.faces.ViewState
-         * Enhancement partial page submit
-         *
-         */
-        this.encodeSubmittableFields(this, <DQ>this.dataSource, this.partialIdsArray);
-
-        if (this.getIf(P_VIEWSTATE).isPresent()) {
-            return;
-        }
-
-        this.applyViewState(<DQ>this.dataSource);
+            .first().isPresent();
     }
 
     /**
-     * special case viewstate handling
+     * special case view state handling
      *
-     * @param form the form holding the viewstate value
+     * @param form the form holding the view state value
      */
     private applyViewState(form: DQ) {
         let viewState = form.byId(P_VIEWSTATE, true).inputValue;
@@ -125,19 +104,22 @@ export class XhrFormData extends Config {
     }
 
     /**
-     * assignes a url encoded string to this xhrFormData object
+     * assigns an url encoded string to this xhrFormData object
      * as key value entry
      * @param encoded
      */
     assignEncodedString(encoded: string) {
-        //TODO reevaluate this method
-        //this code filters out empty strings as key value pairs
+        // this code filters out empty strings as key value pairs
         let keyValueEntries = decodeURIComponent(encoded).split(/&/gi)
                 .filter(item => !!(item || '')
                 .replace(/\s+/g,''));
         this.assignString(keyValueEntries);
     }
 
+    /**
+     * assign a set of key value pairs passed as array ['key=val1', 'key2=val2']
+     * @param keyValueEntries
+     */
     assignString(keyValueEntries: string[]) {
         let toMerge = new Config({});
 
@@ -161,29 +143,12 @@ export class XhrFormData extends Config {
         this.shallowMerge(toMerge);
     }
 
-// noinspection JSUnusedGlobalSymbols
     /**
-     * @returns a Form data representation
+     * @returns a Form data representation, this is needed for file submits
      */
     toFormData(): FormData {
         let ret: any = new FormData();
-
-        LazyStream.of(...Object.keys(this.value))
-            .filter(key => !(key in this.fileInputs))
-            .each(key => {
-                Stream.of(...this.value[key]).each(item => ret.append(key, item));
-            });
-        Stream.of<string>(...Object.keys(this.fileInputs)).each((key: string) => {
-            DQ.querySelectorAllDeep(`[name='${key}'], [id="${key}"]`).eachElem((elem: HTMLInputElement) => {
-                let identifier = this.resolveSubmitIdentifier(elem);
-                if (!elem?.files?.length) {
-                    ret.append(identifier, elem.value);
-                    return;
-                }
-
-                ret.append(identifier, elem.files[0]);
-            })
-        });
+        this.appendInputs(ret);
         return ret;
     }
 
@@ -213,6 +178,42 @@ export class XhrFormData extends Config {
         return entries.join("&")
     }
 
+    /**
+     * helper to fetch all file inputs from as given root element
+     * @param rootElement
+     * @private
+     */
+    private getFileInputs(rootElement: DQ): DQ {
+        const rootFileInputs = rootElement
+            .filter(elem => elem.matchesSelector("input[type='file']"))
+        const childFileInputs = rootElement
+            .querySelectorAll("input[type='file']");
+
+        return rootFileInputs.concat(childFileInputs);
+    }
+
+    /**
+     * encode the given fields and apply the view state
+     * @private
+     */
+    private applyFormDataToConfig() {
+        //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 javax.faces.ViewState
+         * Enhancement partial page submit
+         *
+         */
+        this.encodeSubmittableFields(this, <DQ>this.dataSource, this.partialIds);
+
+        if (this.getIf(P_VIEWSTATE).isPresent()) {
+            return;
+        }
+
+        this.applyViewState(<DQ>this.dataSource);
+    }
+
     /**
      * determines fields to submit
      * @param {Object} targetBuf - the target form buffer receiving the data
@@ -222,30 +223,25 @@ export class XhrFormData extends Config {
     private encodeSubmittableFields(targetBuf: Config,
                                     parentItem: DQ, partialIds ?: string[]) {
         let toEncode = null;
-        if (this.partialIdsArray && this.partialIdsArray.length) {
-            //in case of our myfaces reduced ppr we only
-            //only submit the partials
+        if (this.partialIds && this.partialIds.length) {
+            // in case of our myfaces reduced ppr we
+            // only submit the partials
             this._value = {};
-            toEncode = new DQ(...this.partialIdsArray);
+            toEncode = new DQ(...this.partialIds);
 
         } else {
-            if (parentItem.isAbsent()) throw "NO_PARITEM";
+            if (parentItem.isAbsent()) throw 'NO_PAR_ITEM';
             toEncode = parentItem;
         }
 
         //lets encode the form elements
-
         this.shallowMerge(toEncode.deepElements.encodeFormElement());
     }
 
-    /**
-     * checks if the given datasource is a multipart request source
-     * multipart is only needed if one of the executes is a file input
-     * since file inputs are stateless, they fall out of the viewstate
-     * and need special handling
-     */
-    get isMultipartRequest(): boolean {
-        return !!Object.keys(this.fileInputs).length;
+    private appendInputs(ret: any) {
+        Stream.of(...Object.keys(this.value))
+            .each(key => {
+                Stream.of(...this.value[key]).each(item => ret.append(key, item));
+            });
     }
-
 }

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

@@ -78,6 +78,7 @@ export class XhrRequest implements AsyncRunnable<XMLHttpRequest> {
      *
      * 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"
@@ -120,19 +121,24 @@ export class XhrRequest implements AsyncRunnable<XMLHttpRequest> {
             let viewState = jsf.getViewState(formElement);
             //encoded we need to decode
             //We generated a base representation of the current form
-            let formData: XhrFormData = new XhrFormData(this.sourceForm);
             //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
-            formData.assignEncodedString(viewState);
-            formData.applyFileInputs(...executesArr());
+            //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);
 
             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);
+
+            // 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);
 
             this.responseContext = passThroughParams.deepCopy;
@@ -162,7 +168,7 @@ export class XhrRequest implements AsyncRunnable<XMLHttpRequest> {
 
             //probably not needed anymore, will test this
             //some webkit based mobile browsers do not follow the w3c spec of
-            // setting the accept headers automatically
+            // setting, they accept headers automatically
             ignoreErr(() => xhrObject.setRequestHeader(REQ_ACCEPT, STD_ACCEPT));
 
             this.sendEvent(BEGIN);
@@ -223,23 +229,23 @@ export class XhrRequest implements AsyncRunnable<XMLHttpRequest> {
      * @param resolve
      * @param reject
      */
-    protected registerXhrCallbacks(resolve: Consumer<any>, reject: Consumer<any>) {
+    private registerXhrCallbacks(resolve: Consumer<any>, reject: Consumer<any>) {
         let xhrObject = this.xhrObject;
 
         xhrObject.onabort = () => {
-            this.onAbort(resolve, reject);
+            this.onAbort(reject);
         };
         xhrObject.ontimeout = () => {
-            this.onTimeout(resolve, reject);
+            this.onTimeout(reject);
         };
         xhrObject.onload = () => {
-            this.onSuccess(this.xhrObject, resolve, reject)
+            this.onSuccess(resolve)
         };
         xhrObject.onloadend = () => {
-            this.onDone(this.xhrObject, resolve, reject);
+            this.onDone(this.xhrObject, resolve);
         };
         xhrObject.onerror = (errorData: any) => {
-            this.onError(errorData, resolve, reject);
+            this.onError(errorData, reject);
         };
     }
 
@@ -250,29 +256,29 @@ export class XhrRequest implements AsyncRunnable<XMLHttpRequest> {
      * the xhr object depending on its own state
      */
 
-    protected onAbort(resolve: Consumer<any>, reject: Consumer<any>) {
+    private onAbort(reject: Consumer<any>) {
         reject();
     }
 
-    protected onTimeout(resolve: Consumer<any>, reject: Consumer<any>) {
+    private onTimeout(reject: Consumer<any>) {
         this.sendEvent(STATE_EVT_TIMEOUT);
         reject();
     }
 
-    protected onSuccess(data: any, resolve: Consumer<any>, reject: Consumer<any>) {
+    private onSuccess(resolve: Consumer<any>) {
 
         this.sendEvent(COMPLETE);
 
         //malforms always result in empty response xml
         if (!this?.xhrObject?.responseXML) {
-            this.handleMalFormedXML(resolve, reject);
+            this.handleMalFormedXML(resolve);
             return;
         }
 
         jsf.ajax.response(this.xhrObject, this.responseContext.value ?? {});
     }
 
-    private handleMalFormedXML(resolve: Function, reject: Function) {
+    private handleMalFormedXML(resolve: Function) {
         this.stopProgress = true;
         let errorData = {
             type: ERROR,
@@ -293,18 +299,29 @@ export class XhrRequest implements AsyncRunnable<XMLHttpRequest> {
         //non blocking non clearing
     }
 
-    protected onDone(data: any, resolve: Consumer<any>, reject: Consumer<any>) {
+    private onDone(data: any, resolve: Consumer<any>) {
         if (this.stopProgress) {
             return;
         }
         resolve(data);
     }
 
-    protected onError(errorData: any, resolve: Consumer<any>, reject: Consumer<any>) {
+    private onError(errorData: any,  reject: Consumer<any>) {
         this.handleError(errorData);
         reject();
     }
 
+    private sendRequest(formData: XhrFormData) {
+        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);
+        } else {
+            //in case of a normal request we send it normally
+            this.xhrObject.send((isPost) ? formData.toString() : null);
+        }
+    }
+
     /*
      * other helpers
      */
@@ -331,15 +348,4 @@ export class XhrRequest implements AsyncRunnable<XMLHttpRequest> {
         Implementation.sendError(errorData, eventHandler);
     }
 
-    protected sendRequest(formData: XhrFormData) {
-        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);
-        } else {
-            //in case of a normal request we send it normally
-            this.xhrObject.send((isPost) ? formData.toString() : null);
-        }
-    }
-
 }

package/target/impl/AjaxImpl.js

@@ -62,6 +62,54 @@ var BlockFilter;
  */
 var Implementation;
 (function (Implementation) {
+    /*
+     Small internal explanation, this code is optimized for readability
+     and cuts off a ton of old legacy code.
+     Aka older browsers are not supported anymore.
+     We use a self written helper library to keep the number of exernal
+     code dependencies down.
+     The library is called mona-dish and started as a small sideproject of mine
+     it provides following
+    
+     a) Monad like structures for querying because this keeps the code denser and adds abstractions
+     that always was the strong point of jquery and it still is better in this regard than what ecmascript provides
+    
+     b) Streams and lazystreams like java has, a pull like construct, ecmascript does not have anything like Lazystreams.
+     Another option would have been rxjs but that would have introduced a code dependency and probably more code. We might
+     move to RXJS if the need arises however. But for now I would rather stick with my small self grown library which works
+     quite well and where I can patch quickly (I have used it in several industrial projects, so it works well
+     and is heavily fortified by unit tests (140 testcases as time of writing this))
+    
+     c) A neutral json like configuration which allows assignments of arbitrary values with reduce code which then can be
+     transformed into different data representations
+    
+     examples:
+     internalCtx.assign(MYPARAM, CTX_PARAM_SRC_FRM_ID).value = form.id.value;
+     passes a value into context.MYPARAM.CTX_PARAM_SRC_FRM_ID
+    
+     basically an abbreviation for
+    
+     internalCtxt[MYPARAM] = internalCtxt?.[MYPARAM] ?  internalCtxt[MYPARAM] : {};
+     internalCtxt[MYPARAM][CTX_PARAM_SRC_FRM_ID] = internalCtxt?.[MYPARAM][CTX_PARAM_SRC_FRM_ID] ?  internalCtxt[MYPARAM][CTX_PARAM_SRC_FRM_ID] : {};
+     internalCtxt[MYPARAM][CTX_PARAM_SRC_FRM_ID] = form.id.value;
+    
+    
+     internalCtx.assign(condition, MYPARAM, CTX_PARAM_SRC_FRM_ID).value = form.id.value;
+     passes a value into context.MYPARAM.CTX_PARAM_SRC_FRM_ID if condition === true otherwise it is ignored
+    
+     abbreviates:
+     if(condition) {
+        internalCtxt[MYPARAM] = internalCtxt?.[MYPARAM] ?  internalCtxt[MYPARAM] : {};
+        internalCtxt[MYPARAM][CTX_PARAM_SRC_FRM_ID] = internalCtxt?.[MYPARAM][CTX_PARAM_SRC_FRM_ID] ?  internalCtxt[MYPARAM][CTX_PARAM_SRC_FRM_ID] : {};
+        internalCtxt[MYPARAM][CTX_PARAM_SRC_FRM_ID] = form.id.value;
+     }
+    
+    
+     d) Optional constructs, while under heavy debate we only use them lightly where the api requires it from mona-dish
+    
+     Note the inclusion of this library uses a reduced build which only includes the part of it, which we really use
+    
+     */
     var trim = mona_dish_1.Lang.trim;
     var getMessage = Lang_1.ExtLang.getMessage;
     var getGlobalConfig = Lang_1.ExtLang.getGlobalConfig;
@@ -131,8 +179,9 @@ var Implementation;
             funcs[_i - 2] = arguments[_i];
         }
         return mona_dish_1.LazyStream.of.apply(mona_dish_1.LazyStream, funcs).map(function (func) { return resolveAndExecute(source, event, func); })
-            // we use the return false == stop as an early stop
+            // we use the return false == stop as an early stop, onElem stops at the first false
             .onElem(function (opResult) { return opResult; })
+            //last ensures we run until the first false is returned
             .last().value;
     }
     Implementation.chain = chain;
@@ -158,14 +207,25 @@ var Implementation;
         var _a, _b, _c;
         var _d = (0, RequestDataResolver_1.resolveDefaults)(event, opts, el), resolvedEvent = _d.resolvedEvent, options = _d.options, elem = _d.elem, elementId = _d.elementId, requestCtx = _d.requestCtx, internalCtx = _d.internalCtx, windowId = _d.windowId, isResetValues = _d.isResetValues;
         Assertions_1.Assertions.assertRequestIntegrity(options, elem);
+        /**
+         * fetch the parent form
+         *
+         * note we also add an override possibility here
+         * so that people can use dummy forms and work
+         * with detached objects
+         */
+        var form = (0, RequestDataResolver_1.resolveForm)(requestCtx, elem, resolvedEvent);
+        var formId = form.id.value;
+        var delay = (0, RequestDataResolver_1.resolveDelay)(options);
+        var timeout = (0, RequestDataResolver_1.resolveTimeout)(options);
         requestCtx.assignIf(!!windowId, Const_1.P_WINDOW_ID).value = windowId;
         requestCtx.assign(Const_1.CTX_PARAM_PASS_THR).value = filterPassthroughValues(options.value);
         requestCtx.assignIf(!!resolvedEvent, Const_1.CTX_PARAM_PASS_THR, Const_1.P_EVT).value = resolvedEvent === null || resolvedEvent === void 0 ? void 0 : resolvedEvent.type;
         /**
          * ajax pass through context with the source
-         * onresolvedEvent and onerror
+         * onresolved Event and onerror Event
          */
-        requestCtx.assign(Const_1.SOURCE).value = elementId.value;
+        requestCtx.assign(Const_1.SOURCE).value = elementId;
         /**
          * on resolvedEvent and onError...
          * those values will be traversed later on
@@ -177,26 +237,14 @@ var Implementation;
          * lets drag the myfaces config params also in
          */
         requestCtx.assign(Const_1.MYFACES).value = (_c = options.value) === null || _c === void 0 ? void 0 : _c.myfaces;
-        /**
-         * fetch the parent form
-         *
-         * note we also add an override possibility here
-         * so that people can use dummy forms and work
-         * with detached objects
-         */
-        var form = (0, RequestDataResolver_1.resolveForm)(requestCtx, elem, resolvedEvent);
         /**
          * binding contract the javax.faces.source must be set
          */
-        requestCtx.assign(Const_1.CTX_PARAM_PASS_THR, Const_1.P_PARTIAL_SOURCE).value = elementId.value;
+        requestCtx.assign(Const_1.CTX_PARAM_PASS_THR, Const_1.P_PARTIAL_SOURCE).value = elementId;
         /**
          * javax.faces.partial.ajax must be set to true
          */
         requestCtx.assign(Const_1.CTX_PARAM_PASS_THR, Const_1.P_AJAX).value = true;
-        /**
-         * binding contract the javax.faces.source must be set
-         */
-        requestCtx.assign(Const_1.CTX_PARAM_PASS_THR, Const_1.P_PARTIAL_SOURCE).value = elementId.value;
         /**
          * if resetValues is set to true
          * then we have to set javax.faces.resetValues as well
@@ -205,22 +253,20 @@ var Implementation;
          * the specs jsdoc
          */
         requestCtx.assignIf(isResetValues, Const_1.CTX_PARAM_PASS_THR, Const_1.P_RESET_VALUES).value = true;
-        //additional meta information to speed things up, note internal non jsf
-        //pass through options are stored under _mfInternal in the context
-        internalCtx.assign(Const_1.CTX_PARAM_SRC_FRM_ID).value = form.id.value;
-        internalCtx.assign(Const_1.CTX_PARAM_SRC_CTL_ID).value = elementId.value;
+        // additional meta information to speed things up, note internal non jsf
+        // pass through options are stored under _mfInternal in the context
+        internalCtx.assign(Const_1.CTX_PARAM_SRC_FRM_ID).value = formId;
+        // mojarra compatibility, mojarra is sending the form id as well
+        // this is not documented behavior but can be determined by running
+        // mojarra under blackbox conditions.
+        // I assume it does the same as our formId_submit=1 so leaving it out
+        // won't hurt but for the sake of compatibility we are going to add it
+        requestCtx.assign(Const_1.CTX_PARAM_PASS_THR, formId).value = formId;
+        internalCtx.assign(Const_1.CTX_PARAM_SRC_CTL_ID).value = elementId;
         internalCtx.assign(Const_1.CTX_PARAM_TR_TYPE).value = Const_1.REQ_TYPE_POST;
-        //mojarra compatibility, mojarra is sending the form id as well
-        //this is not documented behavior but can be determined by running
-        //mojarra under blackbox conditions
-        //i assume it does the same as our formId_submit=1 so leaving it out
-        //wont hurt but for the sake of compatibility we are going to add it
-        requestCtx.assign(Const_1.CTX_PARAM_PASS_THR, form.id.value).value = form.id.value;
         assignClientWindowId(form, requestCtx);
-        assignExecute(options, requestCtx, form, elementId.value);
-        assignRender(options, requestCtx, form, elementId.value);
-        var delay = (0, RequestDataResolver_1.resolveDelay)(options);
-        var timeout = (0, RequestDataResolver_1.resolveTimeout)(options);
+        assignExecute(options, requestCtx, form, elementId);
+        assignRender(options, requestCtx, form, elementId);
         //now we enqueue the request as asynchronous runnable into our request
         //queue and let the queue take over the rest
         Implementation.queueHandler.addRequestToQueue(elem, form, requestCtx, internalCtx, delay, timeout);
@@ -242,7 +288,6 @@ var Implementation;
      * @param errorListener the error listener handler
      */
     function addOnError(errorListener) {
-        /*error handling already done in the assert of the queue*/
         errorQueue.push(errorListener);
     }
     Implementation.addOnError = addOnError;
@@ -252,7 +297,6 @@ var Implementation;
      * @param eventListener the event listener handler
      */
     function addOnEvent(eventListener) {
-        /*error handling already done in the assert of the queue*/
         eventQueue.push(eventListener);
     }
     Implementation.addOnEvent = addOnEvent;
@@ -405,7 +449,7 @@ var Implementation;
     Implementation.getViewState = getViewState;
     /**
      * this at the first sight looks like a weird construct, but we need to do it this way
-     * for testing, we cannot proxy addRequestToQueue from the testing frameworks directly
+     * for testing, we cannot proxy addRequestToQueue from the testing frameworks directly,
      * but we need to keep it under unit tests.
      */
     Implementation.queueHandler = {
@@ -496,11 +540,8 @@ var Implementation;
         var iterValues = (userValues) ? trim(userValues).split(/\s+/gi) : [];
         var ret = [];
         var processed = {};
-        //the idea is simply to loop over all values and then replace
-        //their generic values and filter out doubles
-        //this is more readable than the old indexed based solution
-        //and not really slower because we had to build up the index in our old solution
-        //anyway
+        // in this case we do not use lazy stream because it wont bring any code reduction
+        // or speedup
         for (var cnt = 0; cnt < iterValues.length; cnt++) {
             //avoid doubles
             if (iterValues[cnt] in processed) {
@@ -568,7 +609,7 @@ var Implementation;
         }
         else {
             //either a function or a string can be passed in case of a string we have to wrap it into another function
-            //it it is not a plain executable code but a definition
+            //it is not a plain executable code but a definition
             var sourceCode = trim(func);
             if (sourceCode.indexOf("function ") == 0) {
                 sourceCode = "return ".concat(sourceCode, " (event)");