jsf.js_next_gen 4.0.0-RC.13 → 4.0.0-RC.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsf.js_next_gen",
-  "version": "4.0.0-RC.13",
+  "version": "4.0.0-RC.15",
   "description": "A next generation typescript reimplementation of jsf.js",
   "main": "dist/window/faces.js",
   "scripts": {
@@ -22,7 +22,7 @@
   "devDependencies": {
     "@istanbuljs/nyc-config-typescript": "^1.0.2",
     "@types/chai": "^4.3.4",
-    "@types/mocha": "^10.0.0",
+    "@types/mocha": "^10.0.1",
     "@types/node": "^18.11.9",
     "@types/sinon": "^10.0.13",
     "babel-plugin-syntax-dynamic-import": "^6.18.0",
@@ -37,7 +37,7 @@
     "nyc": "^15.1.0",
     "replace-in-file": "^6.3.5",
     "rxjs": "^7.5.7",
-    "sinon": "^14.0.2",
+    "sinon": "^15.0.0",
     "terser-webpack-plugin": "^5.3.6",
     "ts-loader": "^9.4.1",
     "ts-node": "^10.9.1",
@@ -48,6 +48,6 @@
     "webpack-dev-server": "^4.11.1"
   },
   "dependencies": {
-    "mona-dish": "^0.23.9"
+    "mona-dish": "^0.23.10"
   }
 }

package/src/main/typescript/@types/definitions/index.d.ts

@@ -134,6 +134,8 @@ declare global {
         };
     }
 
+
+
     /*
      * Global namespaces type definitions
      */

package/src/main/typescript/api/_api.ts

@@ -16,7 +16,7 @@
 import {Implementation} from "../impl/AjaxImpl";
 import {PushImpl} from "../impl/PushImpl";
 import {oam as _oam} from "../myfaces/OamSubmit";
-import {$nsp, CTX_PARAM_EXECUTE, CTX_PARAM_RENDER, P_BEHAVIOR_EVENT} from "../impl/core/Const";
+import {$nsp, CTX_OPTIONS_EXECUTE, CTX_PARAM_RENDER, P_BEHAVIOR_EVENT} from "../impl/core/Const";
 import {ErrorData} from "../impl/xhrCore/ErrorData";
 import {EventData} from "../impl/xhrCore/EventData";
 
@@ -257,7 +257,7 @@ export module myfaces {
            options[$nsp(P_BEHAVIOR_EVENT)] = eventName;
         }
         if (execute) {
-            options[CTX_PARAM_EXECUTE] = execute;
+            options[CTX_OPTIONS_EXECUTE] = execute;
         }
         if (render) {
             options[CTX_PARAM_RENDER] = render;

package/src/main/typescript/impl/AjaxImpl.ts

@@ -21,17 +21,16 @@ import {AsynchronousQueue} from "./util/AsyncQueue";
 import {AssocArrayCollector, Config, DQ, Lang, LazyStream, Optional, Stream} from "mona-dish";
 import {Assertions} from "./util/Assertions";
 import {XhrFormData} from "./xhrCore/XhrFormData";
-import {ExtDomQuery} from "./util/ExtDomQuery";
+import {ExtConfig, ExtDomQuery} from "./util/ExtDomQuery";
 import {ErrorData} from "./xhrCore/ErrorData";
 import {EventData} from "./xhrCore/EventData";
 import {ExtLang} from "./util/Lang";
 
 import {
-    CTX_PARAM_EXECUTE,
-    CTX_PARAM_PASS_THR,
+    CTX_OPTIONS_EXECUTE,
+    CTX_PARAM_REQ_PASS_THR,
     CTX_PARAM_SRC_CTL_ID,
     CTX_PARAM_SRC_FRM_ID,
-    CTX_PARAM_TR_TYPE,
     IDENT_ALL,
     IDENT_FORM,
     IDENT_NONE,
@@ -48,15 +47,14 @@ import {
     P_RESET_VALUES,
     P_WINDOW_ID,
     CTX_PARAM_RENDER,
-    REQ_TYPE_POST,
     SOURCE,
-    TAG_FORM, CTX_PARAM_SPEC_PARAMS
+    HTML_TAG_FORM, CTX_OPTIONS_PARAMS, VIEW_ID, $faces, EMPTY_STR
 } from "./core/Const";
 import {
     resolveDefaults,
     resolveDelay,
     resolveForm,
-    resolveTimeout
+    resolveTimeout, resolveViewId
 } from "./xhrCore/RequestDataResolver";
 
 /*
@@ -243,15 +241,14 @@ export module Implementation {
     export function request(el: ElemDef, event?: Event, opts ?: Options) {
 
         const {
-            resolvedEvent,
             options,
             elem,
             elementId,
-            requestCtx,
-            internalCtx,
             windowId,
             isResetValues
         } = resolveDefaults(event, opts, el);
+        const requestCtx = new ExtConfig({});
+        const internalCtx = new ExtConfig({});
 
         Assertions.assertRequestIntegrity(options, elem);
 
@@ -262,7 +259,8 @@ export module Implementation {
          * so that people can use dummy forms and work
          * with detached objects
          */
-        const form: DQ = resolveForm(requestCtx, elem, resolvedEvent);
+        const form: DQ = resolveForm(elem, event);
+        const viewId: string = resolveViewId(form);
         const formId = form.id.value;
         const delay: number = resolveDelay(options);
         const timeout: number = resolveTimeout(options);
@@ -270,12 +268,12 @@ export module Implementation {
         requestCtx.assignIf(!!windowId, P_WINDOW_ID).value = windowId;
 
         // old non spec behavior will be removed after it is clear whether the removal breaks any code
-        requestCtx.assign(CTX_PARAM_PASS_THR).value = filterPassThroughValues(options.value);
+        requestCtx.assign(CTX_PARAM_REQ_PASS_THR).value = extractLegacyParams(options.value);
 
         // spec conform behavior, all passthrough params must be under "passthrough
-        const params = remapArrayToAssocArr(options.getIf(CTX_PARAM_SPEC_PARAMS).orElse({}).value);
-        requestCtx.getIf(CTX_PARAM_PASS_THR).shallowMerge(new Config(params), true);
-        requestCtx.assignIf(!!resolvedEvent, CTX_PARAM_PASS_THR, P_EVT).value = resolvedEvent?.type;
+        const params = remapArrayToAssocArr(options.getIf(CTX_OPTIONS_PARAMS).orElse({}).value);
+        requestCtx.getIf(CTX_PARAM_REQ_PASS_THR).shallowMerge(new Config(params), true);
+        requestCtx.assignIf(!!event, CTX_PARAM_REQ_PASS_THR, P_EVT).value = event?.type;
 
         /**
          * ajax pass through context with the source
@@ -283,6 +281,8 @@ export module Implementation {
          */
         requestCtx.assign(SOURCE).value = elementId;
 
+        requestCtx.assign(VIEW_ID).value = viewId;
+
         /**
          * on resolvedEvent and onError...
          * those values will be traversed later on
@@ -299,12 +299,12 @@ export module Implementation {
         /**
          * binding contract the jakarta.faces.source must be set
          */
-        requestCtx.assign(CTX_PARAM_PASS_THR, P_PARTIAL_SOURCE).value = elementId;
+        requestCtx.assign(CTX_PARAM_REQ_PASS_THR, P_PARTIAL_SOURCE).value = elementId;
 
         /**
          * jakarta.faces.partial.ajax must be set to true
          */
-        requestCtx.assign(CTX_PARAM_PASS_THR, P_AJAX).value = true;
+        requestCtx.assign(CTX_PARAM_REQ_PASS_THR, P_AJAX).value = true;
 
         /**
          * if resetValues is set to true
@@ -313,7 +313,7 @@ export module Implementation {
          * the value has to be explicitly true, according to
          * the specs jsdoc
          */
-        requestCtx.assignIf(isResetValues, CTX_PARAM_PASS_THR, P_RESET_VALUES).value = true;
+        requestCtx.assignIf(isResetValues, CTX_PARAM_REQ_PASS_THR, 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
@@ -324,9 +324,8 @@ export module Implementation {
         // 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(CTX_PARAM_PASS_THR, formId).value = formId;
+        requestCtx.assign(CTX_PARAM_REQ_PASS_THR, formId).value = formId;
         internalCtx.assign(CTX_PARAM_SRC_CTL_ID).value = elementId;
-        internalCtx.assign(CTX_PARAM_TR_TYPE).value = REQ_TYPE_POST;
 
         assignClientWindowId(form, requestCtx);
         assignExecute(options, requestCtx, form, elementId);
@@ -512,7 +511,7 @@ export module Implementation {
          */
 
         let element: DQ = DQ.byId(form, true);
-        if (!element.isTag(TAG_FORM)) {
+        if (!element.isTag(HTML_TAG_FORM)) {
             throw new Error(getMessage("ERR_VIEWSTATE"));
         }
 
@@ -553,7 +552,7 @@ export module Implementation {
      */
     function assignRender(requestOptions: Config, targetContext: Config, issuingForm: DQ, sourceElementId: string) {
         if (requestOptions.getIf(CTX_PARAM_RENDER).isPresent()) {
-            remapDefaultConstants(targetContext.getIf(CTX_PARAM_PASS_THR).get({}), P_RENDER, <string>requestOptions.getIf(CTX_PARAM_RENDER).value, issuingForm, <any>sourceElementId);
+            remapDefaultConstants(targetContext.getIf(CTX_PARAM_REQ_PASS_THR).get({}), P_RENDER, <string>requestOptions.getIf(CTX_PARAM_RENDER).value, issuingForm, <any>sourceElementId, targetContext.getIf(VIEW_ID).value);
         }
     }
 
@@ -571,15 +570,15 @@ export module Implementation {
      */
     function assignExecute(requestOptions: Config, targetContext: Config, issuingForm: DQ, sourceElementId: string) {
 
-        if (requestOptions.getIf(CTX_PARAM_EXECUTE).isPresent()) {
+        if (requestOptions.getIf(CTX_OPTIONS_EXECUTE).isPresent()) {
             /*the options must be a blank delimited list of strings*/
             /*compliance with Mojarra which automatically adds @this to an execute
              * the spec rev 2.0a however states, if none is issued nothing at all should be sent down
              */
-            requestOptions.assign(CTX_PARAM_EXECUTE).value = [requestOptions.getIf(CTX_PARAM_EXECUTE).value, IDENT_THIS].join(" ");
-            remapDefaultConstants(targetContext.getIf(CTX_PARAM_PASS_THR).get({}), P_EXECUTE, <string>requestOptions.getIf(CTX_PARAM_EXECUTE).value, issuingForm, <any>sourceElementId);
+            requestOptions.assign(CTX_OPTIONS_EXECUTE).value = [requestOptions.getIf(CTX_OPTIONS_EXECUTE).value, IDENT_THIS].join(" ");
+            remapDefaultConstants(targetContext.getIf(CTX_PARAM_REQ_PASS_THR).get({}), P_EXECUTE, <string>requestOptions.getIf(CTX_OPTIONS_EXECUTE).value, issuingForm, <any>sourceElementId, targetContext.getIf(VIEW_ID).value);
         } else {
-            targetContext.assign(CTX_PARAM_PASS_THR, P_EXECUTE).value = sourceElementId;
+            targetContext.assign(CTX_PARAM_REQ_PASS_THR, P_EXECUTE).value = sourceElementId;
         }
     }
 
@@ -591,16 +590,16 @@ export module Implementation {
      */
     function assignClientWindowId(form: DQ, targetContext: Config) {
 
-        let clientWindow = (window?.faces ?? window?.jsf).getClientWindow(form.getAsElem(0).value);
+        let clientWindow = $faces().getClientWindow(form.getAsElem(0).value);
         if (clientWindow) {
-            targetContext.assign(CTX_PARAM_PASS_THR, P_CLIENT_WINDOW).value = clientWindow;
+            targetContext.assign(CTX_PARAM_REQ_PASS_THR, P_CLIENT_WINDOW).value = clientWindow;
         }
     }
 
     /**
      * transforms the user values to the expected one
      * with the proper none all form and this handling
-     * (note we also could use a simple string replace but then
+     * (note we also could use a simple string replace, but then
      * we would have had double entries under some circumstances)
      *
      * there are several standardized constants which need a special treatment
@@ -611,14 +610,55 @@ export module Implementation {
      * @param userValues the passed user values (aka input string which needs to be transformed)
      * @param issuingForm the form where the issuing element originates
      * @param issuingElementId the issuing element
+     * @param rootNamingContainerId the naming container id ("" default if none is given)
      */
-    function remapDefaultConstants(targetConfig: Config, targetKey: string, userValues: string, issuingForm: DQ, issuingElementId: string): Config {
+    function remapDefaultConstants(targetConfig: Config, targetKey: string, userValues: string, issuingForm: DQ, issuingElementId: string, rootNamingContainerId: string = ""): Config {
         //a cleaner implementation of the transform list method
-
+        const SEP = $faces().separatorchar;
         let iterValues: string[] = (userValues) ? trim(userValues).split(/\s+/gi) : [];
         let ret = [];
         let processed: {[key: string]: boolean} = {};
 
+        /**
+         * remaps the client ids for the portlet case so that the server
+         * can deal with them either prefixed ir not
+         * also resolves the absolute id case (it was assumed the server does this, but
+         * apparently the RI does not, so we have to follow the RI behavior here)
+         * @param componentIdToTransform the componentId which needs post processing
+         */
+        const remapNamingContainer = componentIdToTransform => {
+            // pattern :<anything> must be prepended by viewRoot if there is one,
+            // otherwise we are in a not namespaced then only the id has to match
+            const rootNamingContainerPrefix = (rootNamingContainerId.length) ? rootNamingContainerId+SEP : EMPTY_STR;
+            let formClientId = issuingForm.id.value;
+            // nearest parent naming container relative to the form
+            const nearestNamingContainer = formClientId.substring(0, formClientId.lastIndexOf(SEP));
+            const nearestNamingContainerPrefix = (nearestNamingContainer.length) ? nearestNamingContainer + SEP : EMPTY_STR;
+            // Absolute search expressions, always start with SEP or the name of the root naming container
+            const hasLeadingSep = componentIdToTransform.indexOf(SEP) === 0;
+            const isAbsolutSearchExpr = hasLeadingSep || (rootNamingContainerId.length
+                && componentIdToTransform.indexOf(rootNamingContainerPrefix) == 0);
+
+            if (isAbsolutSearchExpr) {
+                //we cut off the leading sep if there is one
+                componentIdToTransform = hasLeadingSep ? componentIdToTransform.substring(1) : componentIdToTransform;
+                componentIdToTransform = componentIdToTransform.indexOf(rootNamingContainerPrefix) == 0 ? componentIdToTransform.substring(rootNamingContainerPrefix.length) : componentIdToTransform;
+                //now we prepend either the prefix or "" from the cut-off string to get the final result
+                return  [rootNamingContainerPrefix, componentIdToTransform].join(EMPTY_STR);
+            } else { //relative search according to the javadoc
+                //we cut off the root naming container id from the form
+                if (formClientId.indexOf(rootNamingContainerPrefix) == 0) {
+                    formClientId = formClientId.substring(rootNamingContainerPrefix.length);
+                }
+
+                //If prependId = true, the outer form id must be present in the id if same form
+                let hasPrependId = componentIdToTransform.indexOf(formClientId) == 0;
+                return hasPrependId ?
+                    [rootNamingContainerPrefix, componentIdToTransform].join(EMPTY_STR) :
+                    [nearestNamingContainerPrefix,  componentIdToTransform.substring(componentIdToTransform.lastIndexOf(SEP) + 1)].join(EMPTY_STR);
+            }
+        };
+
         // in this case we do not use lazy stream because it wont bring any code reduction
         // or speedup
         for (let cnt = 0; cnt < iterValues.length; cnt++) {
@@ -636,39 +676,39 @@ export module Implementation {
                     return targetConfig;
                 //@form pushes the issuing form id into our list
                 case IDENT_FORM:
-                    ret.push(issuingForm.id.value);
+                    ret.push(remapNamingContainer(issuingForm.id.value));
                     processed[issuingForm.id.value] = true;
                     break;
                 //@this is replaced with the current issuing element id
                 case IDENT_THIS:
                     if (!(issuingElementId in processed)) {
-                        ret.push(issuingElementId);
+                        ret.push(remapNamingContainer(issuingElementId));
                         processed[issuingElementId] = true;
                     }
                     break;
                 default:
-                    ret.push(iterValues[cnt]);
+                    ret.push(remapNamingContainer(iterValues[cnt]));
                     processed[iterValues[cnt]] = true;
             }
         }
-        //We now add the target as joined list
+
         targetConfig.assign(targetKey).value = ret.join(" ");
         return targetConfig;
     }
 
     /**
      * Filter the options given with a blacklist, so that only
-     * the values required for pass-through are processed in the ajax request
+     * the values required for params-through are processed in the ajax request
      *
      * Note this is a bug carried over from the old implementation
      * the spec conform behavior is to use params for passthrough values
-     * this will be removed soon, after it is cleared up wheter removing
+     * this will be removed soon, after it is cleared up whether removing
      * it breaks any legacy code
      *
      * @param {Context} mappedOpts the options to be filtered
      * @deprecated
      */
-    function filterPassThroughValues(mappedOpts: Context): Context {
+    function extractLegacyParams(mappedOpts: Options): Context {
         //we now can use the full code reduction given by our stream api
         //to filter
         return Stream.ofAssoc(mappedOpts)

package/src/main/typescript/impl/core/Const.ts

@@ -17,8 +17,11 @@
 /*
  * [export const] constants
  */
+
+
 export const P_PARTIAL_SOURCE = "jakarta.faces.source";
 export const PARTIAL_ID = "partialId";
+export const VIEW_ID = "myfaves.viewId";
 export const P_VIEWSTATE = "jakarta.faces.ViewState";
 export const P_CLIENT_WINDOW = "jakarta.faces.ClientWindow";
 export const P_VIEWROOT = "jakarta.faces.ViewRoot";
@@ -91,21 +94,17 @@ export const SERVER_ERROR = "serverError";
 export const CLIENT_ERROR = "clientError";
 export const TIMEOUT_EVENT = "timeout";
 
-export const CTX_PARAM_MF_INTERNAL = "_mfInternal";
-
-export const CTX_PARAM_SRC_FRM_ID = "_mfSourceFormId";
-export const CTX_PARAM_SRC_CTL_ID = "_mfSourceControlId";
-export const CTX_PARAM_TR_TYPE = "_mfTransportType";
-export const CTX_PARAM_PASS_THR = "passThrgh";
-export const CTX_PARAM_SPEC_PARAMS = "params";
-
-export const CTX_PARAM_DELAY = "delay";
-export const CTX_PARAM_TIMEOUT = "timeout";
-export const CTX_PARAM_RST = "resetValues";
-export const CTX_PARAM_EXECUTE = "execute";
-
-export const STAGE_DEVELOPMENT = "Development";
+export const CTX_OPTIONS_PARAMS = "params";
+export const CTX_OPTIONS_DELAY = "delay";
+export const DELAY_NONE = 'none';
+export const CTX_OPTIONS_TIMEOUT = "timeout";
+export const CTX_OPTIONS_RESET = "resetValues";
+export const CTX_OPTIONS_EXECUTE = "execute";
 
+export const CTX_PARAM_MF_INTERNAL = "myfaces.internal";
+export const CTX_PARAM_SRC_FRM_ID = "myfaces.source.formId";
+export const CTX_PARAM_SRC_CTL_ID = "myfaces.source.controlId";
+export const CTX_PARAM_REQ_PASS_THR = "myfaces.request.passThrough";
 
 export const CONTENT_TYPE = "Content-Type";
 export const HEAD_FACES_REQ = "Faces-Request";
@@ -122,13 +121,12 @@ export const MULTIPART = "multipart/form-data";
 export const NO_TIMEOUT = 0;
 export const STD_ACCEPT = "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8";
 
-export const TAG_HEAD = "HEAD";
-export const TAG_FORM = "FORM";
-export const TAG_BODY = "BODY";
-export const TAG_BEFORE = "before";
-export const TAG_AFTER = "after";
-
-export const TAG_ATTR = "attribute";
+export const HTML_TAG_HEAD = "HEAD";
+export const HTML_TAG_FORM = "FORM";
+export const HTML_TAG_BODY = "BODY";
+export const HTML_TAG_LINK = "LINK";
+export const HTML_TAG_SCRIPT = "SCRIPT";
+export const HTML_TAG_STYLE = "STYLE";
 
 
 export const SEL_VIEWSTATE_ELEM = "[name='" + P_VIEWSTATE + "']";
@@ -146,38 +144,40 @@ export const ATTR_VALUE = "value";
 export const ATTR_ID = "id";
 
 /*partial response types*/
-export const RESP_PARTIAL = "partial-response";
+export const XML_TAG_PARTIAL_RESP = "partial-response";
 
 /*partial commands*/
-export const CMD_CHANGES = "changes";
-export const CMD_UPDATE = "update";
-export const CMD_DELETE = "delete";
-export const CMD_INSERT = "insert";
-export const CMD_EVAL = "eval";
-export const CMD_ERROR = "error";
-export const CMD_ATTRIBUTES = "attributes";
-export const CMD_EXTENSION = "extension";
-export const CMD_REDIRECT = "redirect";
+export const XML_TAG_CHANGES = "changes";
+export const XML_TAG_UPDATE = "update";
+export const XML_TAG_DELETE = "delete";
+export const XML_TAG_INSERT = "insert";
+export const XML_TAG_EVAL = "eval";
+export const XML_TAG_ERROR = "error";
+export const XML_TAG_ATTRIBUTES = "attributes";
+export const XML_TAG_EXTENSION = "extension";
+export const XML_TAG_REDIRECT = "redirect";
+export const XML_TAG_BEFORE = "before";
+export const XML_TAG_AFTER = "after";
+export const XML_TAG_ATTR = "attribute";
+
 
 /*other constants*/
 
-export const UPDATE_FORMS = "_updateForms";
-export const UPDATE_ELEMS = "_updateElems";
+export const UPDATE_FORMS = "myfaces.updateForms";
+export const UPDATE_ELEMS = "myfaces.updateElems";
 
 //we want the head elements to be processed before we process the body
 //but after the inner html is done
-export const DEFERRED_HEAD_INSERTS = "_headElems";
+export const DEFERRED_HEAD_INSERTS = "myfaces.headElems";
 
 export const MYFACES = "myfaces";
 
-export const SEL_SCRIPTS_STYLES = "script, style, link";
-
 export const MF_NONE = "__mf_none__";
 
 export const REASON_EXPIRED = "Expired";
 
-export const APPLIED_VST = "appliedViewState";
-export const APPLIED_CLIENT_WINDOW = "appliedClientWindow";
+export const APPLIED_VST = "myfaces.appliedViewState";
+export const APPLIED_CLIENT_WINDOW = "myfaces.appliedClientWindow";
 
 export const RECONNECT_INTERVAL = 500;
 export const MAX_RECONNECT_ATTEMPTS = 25;
@@ -192,6 +192,10 @@ export const UNKNOWN = "UNKNOWN";
  * changed to a simple value passthrough
  */
 
+export function $faces(): FacesAPI {
+     return (window?.faces ?? window?.jsf) as FacesAPI;
+}
+
 export function $nsp(inputNamespace?: any): any {
      if((!inputNamespace) || !inputNamespace?.replace) {
           return inputNamespace;

package/src/main/typescript/impl/util/Assertions.ts

@@ -23,7 +23,7 @@ import {
     ON_ERROR,
     ON_EVENT,
     PHASE_PROCESS_RESPONSE,
-    RESP_PARTIAL
+    XML_TAG_PARTIAL_RESP
 } from "../core/Const";
 import {ExtLang} from "./Lang";
 
@@ -60,7 +60,7 @@ export module Assertions {
     export function assertValidXMLResponse(responseXML: XMLQuery) : void | never  {
         assert(!responseXML.isAbsent(), EMPTY_RESPONSE, PHASE_PROCESS_RESPONSE);
         assert(!responseXML.isXMLParserError(),  responseXML.parserErrorText(EMPTY_STR), PHASE_PROCESS_RESPONSE);
-        assert(responseXML.querySelectorAll(RESP_PARTIAL).isPresent(), ERR_NO_PARTIAL_RESPONSE, PHASE_PROCESS_RESPONSE);
+        assert(responseXML.querySelectorAll(XML_TAG_PARTIAL_RESP).isPresent(), ERR_NO_PARTIAL_RESPONSE, PHASE_PROCESS_RESPONSE);
     }
 
     /**

package/src/main/typescript/impl/util/ExtDomQuery.ts

@@ -201,8 +201,8 @@ export class ExtDomQuery extends DQ {
                 return true;
             }
             let reference = element.attr("href")
-                .orElse(element.attr("src").value)
-                .orElse(element.attr("rel").value);
+                .orElseLazy(() => element.attr("src").value)
+                .orElseLazy(() => element.attr("rel").value);
 
             if (!reference.isPresent()) {
                 return true;

package/src/main/typescript/impl/util/HiddenInputBuilder.ts

@@ -0,0 +1,63 @@
+/*! Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import {DomQuery, DQ, DQ$} from "mona-dish";
+import {$faces, $nsp, HTML_CLIENT_WINDOW, HTML_VIEWSTATE, P_CLIENT_WINDOW, P_VIEWSTATE} from "../core/Const";
+
+/**
+ * Builder for hidden inputs.
+ * ATM only ViewState and Client window
+ * are supported (per spec)
+ *
+ * Improves readability in the response processor!
+ */
+export class HiddenInputBuilder {
+    private namingContainerId?: string;
+    private parent?: DomQuery;
+    private readonly name: string;
+    private readonly template: string;
+
+    constructor(private selector: string) {
+        const isViewState = selector.indexOf($nsp(P_VIEWSTATE)) != -1;
+        this.name = isViewState ? P_VIEWSTATE : P_CLIENT_WINDOW
+        this.template = isViewState ? HTML_VIEWSTATE : HTML_CLIENT_WINDOW
+    }
+
+    withNamingContainerId(namingContainer: string): HiddenInputBuilder {
+        this.namingContainerId = namingContainer;
+        return this;
+    }
+
+    withParent(parent: DomQuery): HiddenInputBuilder {
+        this.parent = parent;
+        return this;
+    }
+
+
+    build(): DomQuery {
+        //TODO naming container id?
+        const cnt = DQ$(`[name='${$nsp(this.name)}']`).length;
+        const SEP = $faces().separatorchar;
+        const newElement = DQ.fromMarkup($nsp(this.template));
+        newElement.id.value = ((this.namingContainerId?.length) ?
+            [this.namingContainerId,  $nsp(this.name),  cnt]:
+            [$nsp(this.name),  cnt]).join(SEP);
+
+        this?.parent?.append(newElement);
+        return newElement;
+    }
+}

package/src/main/typescript/impl/util/Lang.ts

@@ -13,13 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * todo replace singleton with module definition
- *
  */
 
 import {Lang as LangBase, Config, Optional, DomQuery, DQ, Stream} from "mona-dish";
 import {Messages} from "../i18n/Messages";
-import {EMPTY_STR, TAG_FORM} from "../core/Const";
+import {EMPTY_STR, HTML_TAG_FORM} from "../core/Const";
 import {getEventTarget} from "../xhrCore/RequestDataResolver";
 
 
@@ -162,23 +160,23 @@ export module ExtLang {
         let queryElem = new DQ(elem);
         let eventTarget = (event) ?  new DQ(getEventTarget(event)) : DomQuery.absent;
 
-        if (queryElem.isTag(TAG_FORM)) {
+        if (queryElem.isTag(HTML_TAG_FORM)) {
             return queryElem;
         }
 
         //html 5 for handling
-        if (queryElem.attr(TAG_FORM).isPresent()) {
-            let formId = queryElem.attr(TAG_FORM).value;
+        if (queryElem.attr(HTML_TAG_FORM).isPresent()) {
+            let formId = queryElem.attr(HTML_TAG_FORM).value;
             let foundForm = DQ.byId(formId, true);
             if (foundForm.isPresent()) {
                 return foundForm;
             }
         }
 
-        let form = queryElem.firstParent(TAG_FORM)
-            .orElseLazy(() => queryElem.byTagName(TAG_FORM, true))
-            .orElseLazy(() => eventTarget.firstParent(TAG_FORM))
-            .orElseLazy(() => eventTarget.byTagName(TAG_FORM))
+        let form = queryElem.firstParent(HTML_TAG_FORM)
+            .orElseLazy(() => queryElem.byTagName(HTML_TAG_FORM, true))
+            .orElseLazy(() => eventTarget.firstParent(HTML_TAG_FORM))
+            .orElseLazy(() => eventTarget.byTagName(HTML_TAG_FORM))
             .first();
 
         assertFormExists(form);

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

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import {Config, DQ} from "mona-dish";
-import {BEGIN, CTX_PARAM_PASS_THR, EVENT, P_PARTIAL_SOURCE, SOURCE} from "../core/Const";
+import {BEGIN, CTX_PARAM_REQ_PASS_THR, EVENT, P_PARTIAL_SOURCE, SOURCE} from "../core/Const";
 
 export class EventData implements IEventData{
     type: string;
@@ -33,7 +33,7 @@ export class EventData implements IEventData{
 
         let sourceId: string = context.getIf(SOURCE)
             .orElseLazy(() => context.getIf(P_PARTIAL_SOURCE).value)
-            .orElseLazy(() => context.getIf(CTX_PARAM_PASS_THR, P_PARTIAL_SOURCE).value)
+            .orElseLazy(() => context.getIf(CTX_PARAM_REQ_PASS_THR, P_PARTIAL_SOURCE).value)
             .value;
         if (sourceId) {
             eventData.source = DQ.byId(sourceId, true).first().value.value;