jsf.js_next_gen 4.0.0-RC.3 → 4.0.0-RC.30

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

@@ -20,23 +20,23 @@ import {ResponseProcessor} from "./ResponseProcessor";
 import {IResponseProcessor} from "./IResponseProcessor";
 import {
     $nsp,
-    CMD_ATTRIBUTES,
-    CMD_CHANGES,
-    CMD_DELETE,
-    CMD_ERROR,
-    CMD_EVAL,
-    CMD_EXTENSION,
-    CMD_INSERT,
-    CMD_REDIRECT,
-    CMD_UPDATE, P_RESOURCE,
+    XML_TAG_ATTRIBUTES,
+    XML_TAG_CHANGES,
+    XML_TAG_DELETE,
+    XML_TAG_ERROR,
+    XML_TAG_EVAL,
+    XML_TAG_EXTENSION,
+    XML_TAG_INSERT,
+    XML_TAG_REDIRECT,
+    XML_TAG_UPDATE, P_RESOURCE,
     P_VIEWBODY,
     P_VIEWHEAD,
     P_VIEWROOT,
-    PARTIAL_ID,
-    RESP_PARTIAL,
+    NAMING_CONTAINER_ID,
+    XML_TAG_PARTIAL_RESP,
     RESPONSE_XML,
-    TAG_AFTER,
-    TAG_BEFORE
+    XML_TAG_AFTER,
+    XML_TAG_BEFORE, NAMED_VIEWROOT, XML_ATTR_NAMED_VIEWROOT, P_VIEWSTATE, $faces
 } from "../core/Const";
 import {resolveContexts, resolveResponseXML} from "./ResonseDataResolver";
 import {ExtConfig} from "../util/ExtDomQuery";
@@ -67,7 +67,7 @@ export module Response {
         internalContext.assign(RESPONSE_XML).value = responseXML;
 
         // we now process the partial tags, or in none given raise an error
-        responseXML.querySelectorAll(RESP_PARTIAL)
+        responseXML.querySelectorAll(XML_TAG_PARTIAL_RESP)
             .each(item => processPartialTag(<XMLQuery>item, responseProcessor, internalContext));
 
         // We now process the viewStates, client windows and the elements to be evaluated are delayed.
@@ -76,6 +76,7 @@ export module Response {
         // doing any evaluations even on embedded scripts.
         // Usually this does not matter, the client window comes in almost last always anyway
         // we maybe drop this deferred assignment in the future, but myfaces did it until now.
+        responseProcessor.updateNamedViewRootState();
         responseProcessor.fixViewStates();
         responseProcessor.fixClientWindow();
         responseProcessor.globalEval();
@@ -86,35 +87,51 @@ export module Response {
     /**
      * highest node partial-response from there the main operations are triggered
      */
-     function processPartialTag(node: XMLQuery, responseProcessor: IResponseProcessor, internalContext) {
+    function processPartialTag(node: XMLQuery, responseProcessor: IResponseProcessor, internalContext) {
 
-        internalContext.assign(PARTIAL_ID).value = node.id;
-        const SEL_SUB_TAGS = [CMD_ERROR, CMD_REDIRECT, CMD_CHANGES].join(",");
+
+        /*
+        https://javaee.github.io/javaserverfaces/docs/2.2/javadocs/web-partialresponse.html#ns_xsd
+        The "partial-response" element is the root of the partial response information hierarchy,
+        and contains nested elements for all possible elements that can exist in the response.
+        This element must have an "id" attribute whose value is the return from calling getContainerClientId()
+        on the UIViewRoot to which this response pertains.
+         */
+        // we can determine whether we are in a naming container scenario by checking whether the passed view id is present in the page
+        // under or in body as identifier
+
+        let partialId:string = node?.id?.value;
+        internalContext.assignIf(!!partialId, NAMING_CONTAINER_ID).value = partialId; // second case mojarra
+
+        // there must be at least one container viewstate element resembling the viewroot that we know
+        // this is named
+        responseProcessor.updateNamedViewRootState();
+
+        const SEL_SUB_TAGS = [XML_TAG_ERROR, XML_TAG_REDIRECT, XML_TAG_CHANGES].join(",");
 
         // now we can process the main operations
         node.querySelectorAll(SEL_SUB_TAGS).each((node: XMLQuery) => {
             switch (node.tagName.value) {
-                case CMD_ERROR:
+                case XML_TAG_ERROR:
                     responseProcessor.error(node);
                     break;
-                case CMD_REDIRECT:
+                case XML_TAG_REDIRECT:
                     responseProcessor.redirect(node);
                     break;
-                case CMD_CHANGES:
+                case XML_TAG_CHANGES:
                     processChangesTag(node, responseProcessor);
                     break;
             }
         });
-
     }
 
     let processInsert = function (responseProcessor: IResponseProcessor, node: XMLQuery) {
-         // path1 insert after as child tags
-         if(node.querySelectorAll([TAG_BEFORE, TAG_AFTER].join(",")).length) {
-             responseProcessor.insertWithSubTags(node);
-         } else { // insert before after with id
-             responseProcessor.insert(node);
-         }
+        // path1 insert after as child tags
+        if(node.querySelectorAll([XML_TAG_BEFORE, XML_TAG_AFTER].join(",")).length) {
+            responseProcessor.insertWithSubTags(node);
+        } else { // insert before after with id
+            responseProcessor.insert(node);
+        }
 
     };
 
@@ -124,32 +141,32 @@ export module Response {
      * @param node
      * @param responseProcessor
      */
-     function processChangesTag(node: XMLQuery, responseProcessor: IResponseProcessor): boolean {
-        const ALLOWED_TAGS = [CMD_UPDATE, CMD_EVAL, CMD_INSERT, CMD_DELETE, CMD_ATTRIBUTES, CMD_EXTENSION].join(", ");
+    function processChangesTag(node: XMLQuery, responseProcessor: IResponseProcessor): boolean {
+        const ALLOWED_TAGS = [XML_TAG_UPDATE, XML_TAG_EVAL, XML_TAG_INSERT, XML_TAG_DELETE, XML_TAG_ATTRIBUTES, XML_TAG_EXTENSION].join(", ");
         node.querySelectorAll(ALLOWED_TAGS).each(
             (node: XMLQuery) => {
                 switch (node.tagName.value) {
-                    case CMD_UPDATE:
+                    case XML_TAG_UPDATE:
                         processUpdateTag(node, responseProcessor);
                         break;
 
-                    case CMD_EVAL:
+                    case XML_TAG_EVAL:
                         responseProcessor.eval(node);
                         break;
 
-                    case CMD_INSERT:
+                    case XML_TAG_INSERT:
                         processInsert(responseProcessor, node);
                         break;
 
-                    case CMD_DELETE:
+                    case XML_TAG_DELETE:
                         responseProcessor.delete(node);
                         break;
 
-                    case CMD_ATTRIBUTES:
+                    case XML_TAG_ATTRIBUTES:
                         responseProcessor.attributes(node);
                         break;
 
-                    case CMD_EXTENSION:
+                    case XML_TAG_EXTENSION:
                         break;
                 }
             }
@@ -177,8 +194,8 @@ export module Response {
      * @param node
      * @param responseProcessor
      */
-     function processUpdateTag(node: XMLQuery, responseProcessor: IResponseProcessor) {
-         // early state storing, if no state we perform a normal update cycle
+    function processUpdateTag(node: XMLQuery, responseProcessor: IResponseProcessor) {
+        // early state storing, if no state we perform a normal update cycle
         if (!storeState(responseProcessor, node)) {
             handleElementUpdate(node, responseProcessor);
         }
@@ -190,7 +207,7 @@ export module Response {
      * @param node
      * @param responseProcessor
      */
-     function handleElementUpdate(node: XMLQuery, responseProcessor: IResponseProcessor) {
+    function handleElementUpdate(node: XMLQuery, responseProcessor: IResponseProcessor) {
         let cdataBlock = node.cDATAAsString;
         switch (node.id.value) {
             case $nsp(P_VIEWROOT) :

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

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import {Config, DomQuery, DQ, Lang, Stream, XMLQuery} from "mona-dish";
+import {Config, DomQuery, DomQueryCollector, DQ, DQ$, Lang, LazyStream, Stream, XMLQuery} from "mona-dish";
 import {Implementation} from "../AjaxImpl";
 import {Assertions} from "../util/Assertions";
 import {IResponseProcessor} from "./IResponseProcessor";
@@ -23,6 +23,7 @@ import {StateHolder} from "../core/ImplTypes";
 import {EventData} from "./EventData";
 
 import {
+    $faces,
     $nsp,
     APPLIED_CLIENT_WINDOW,
     APPLIED_VST,
@@ -30,32 +31,40 @@ import {
     ATTR_NAME,
     ATTR_URL,
     ATTR_VALUE,
+    DEFERRED_HEAD_INSERTS,
     EMPTY_FUNC,
     EMPTY_STR,
     ERROR_MESSAGE,
     ERROR_NAME,
-    HTML_VIEWSTATE,
+    HTML_TAG_BODY,
+    HTML_TAG_FORM,
+    HTML_TAG_HEAD,
+    HTML_TAG_LINK,
+    HTML_TAG_SCRIPT,
+    HTML_TAG_STYLE, IDENT_ALL, IDENT_NONE, NAMED_VIEWROOT,
     ON_ERROR,
-    ON_EVENT, P_CLIENT_WINDOW,
+    ON_EVENT,
+    P_CLIENT_WINDOW,
+    P_EXECUTE,
     P_PARTIAL_SOURCE,
+    P_RENDER,
+    P_RENDER_OVERRIDE,
     P_VIEWSTATE,
-    RESPONSE_XML, SEL_CLIENT_WINDOW_ELEM,
-    SEL_SCRIPTS_STYLES,
+    NAMING_CONTAINER_ID,
+    RESPONSE_XML,
+    SEL_CLIENT_WINDOW_ELEM,
     SEL_VIEWSTATE_ELEM,
     SOURCE,
     SUCCESS,
-    TAG_AFTER,
-    TAG_ATTR,
-    TAG_BEFORE,
-    TAG_BODY,
-    TAG_FORM,
-    TAG_HEAD,
     UPDATE_ELEMS,
     UPDATE_FORMS,
-    DEFERRED_HEAD_INSERTS
+    XML_TAG_AFTER,
+    XML_TAG_ATTR,
+    XML_TAG_BEFORE
 } from "../core/Const";
-import trim = Lang.trim;
 import {ExtConfig, ExtDomQuery} from "../util/ExtDomQuery";
+import {HiddenInputBuilder} from "../util/HiddenInputBuilder";
+import trim = Lang.trim;
 
 
 /**
@@ -82,31 +91,38 @@ export class ResponseProcessor implements IResponseProcessor {
      * the data incoming must represent the html representation of the head itself one way or the other
      */
     replaceHead(shadowDocument: XMLQuery | DQ) {
-        let shadowHead = shadowDocument.querySelectorAll(TAG_HEAD);
+        const shadowHead = shadowDocument.querySelectorAll(HTML_TAG_HEAD);
         if (!shadowHead.isPresent()) {
             return;
         }
+        const head = ExtDomQuery.querySelectorAll(HTML_TAG_HEAD);
+        // full replace we delete everything
+        head.childNodes.delete();
+        this.addToHead(shadowHead);
+        //we copy the attributes as well (just in case myfaces introduces the id in head)
+        head.copyAttrs(shadowHead);
+    }
 
-        let oldHead = ExtDomQuery.querySelectorAll(TAG_HEAD);
-
-        //delete all to avoid script and style overlays
-        oldHead.querySelectorAll(SEL_SCRIPTS_STYLES).delete();
+    addToHead(shadowHead: XMLQuery | DQ) {
+        const mappedHeadData = new ExtDomQuery(shadowHead);
+        const scriptTags = [HTML_TAG_SCRIPT];
+        const nonExecutables = mappedHeadData.filter(item => scriptTags.indexOf(item.tagName.orElse("").value) == -1);
+        nonExecutables.runHeadInserts(true);
 
-        // we cannot replace new elements in the head, but we can eval the elements
-        // eval means the scripts will get attached (eval script attach method)
-        // but this is done by DomQuery not in this code
-        this.storeForEval(shadowHead);
         //incoming either the outer head tag or its children
-        //shadowHead = (shadowHead.tagName.value === "HEAD") ? shadowHead.childNodes : shadowHead;
-        //this.addToHead(shadowHead);
+        const nodesToAdd = (shadowHead.tagName.value === "HEAD") ? shadowHead.childNodes : shadowHead;
+        // this is stored for "post" processing
+        // after the rest of the "physical build up", head before body
+        const scriptElements = nodesToAdd.stream
+            .filter(item => scriptTags.indexOf(item.tagName.orElse("").value) != -1).collect(new DomQueryCollector());
+
+        this.addToHeadDeferred(scriptElements);
     }
 
-    addToHead(newElements: XMLQuery | DQ) {
+    addToHeadDeferred(newElements: XMLQuery | DQ) {
         this.internalContext.assign(DEFERRED_HEAD_INSERTS).value.push(newElements);
     }
 
-
-
     /**
      * replaces the body in the expected manner
      * which means the entire body content is refreshed
@@ -117,21 +133,20 @@ export class ResponseProcessor implements IResponseProcessor {
      */
     replaceBody(shadowDocument: XMLQuery | DQ) {
 
-        let shadowBody = shadowDocument.querySelectorAll(TAG_BODY);
+        const shadowBody = shadowDocument.querySelectorAll(HTML_TAG_BODY);
         if (!shadowBody.isPresent()) {
             return;
         }
 
-        let shadowInnerHTML: string = <string>shadowBody.html().value;
-
-        let resultingBody = <DQ>ExtDomQuery.querySelectorAll(TAG_BODY).html(shadowInnerHTML);
-        let updateForms = resultingBody.querySelectorAll(TAG_FORM);
+        const shadowInnerHTML: string = <string>shadowBody.innerHTML;
+        const resultingBody = <DQ>ExtDomQuery.querySelectorAll(HTML_TAG_BODY);
+        const updateForms = resultingBody.querySelectorAll(HTML_TAG_FORM);
 
         // main difference, we cannot replace the body itself, but only its content
         // we need a separate step for post-processing the incoming
         // attributes, like classes, styles etc...
-        resultingBody.copyAttrs(shadowBody);
-
+        (resultingBody.html(shadowInnerHTML) as DQ).copyAttrs(shadowBody);
+        this.externalContext.assign($nsp(P_RENDER_OVERRIDE)).value = "@all";
         this.storeForPostProcessing(updateForms, resultingBody);
     }
 
@@ -158,18 +173,18 @@ export class ResponseProcessor implements IResponseProcessor {
          * <error>
          */
 
-        let mergedErrorData = new ExtConfig({});
+        const mergedErrorData = new ExtConfig({});
         mergedErrorData.assign(SOURCE).value = this.externalContext.getIf(P_PARTIAL_SOURCE).get(0).value;
         mergedErrorData.assign(ERROR_NAME).value = node.querySelectorAll(ERROR_NAME).textContent(EMPTY_STR);
         mergedErrorData.assign(ERROR_MESSAGE).value = node.querySelectorAll(ERROR_MESSAGE).cDATAAsString;
 
-        let hasResponseXML = this.internalContext.get(RESPONSE_XML).isPresent();
+        const hasResponseXML = this.internalContext.get(RESPONSE_XML).isPresent();
 
         //we now store the response xml also in the error data for further details
         mergedErrorData.assignIf(hasResponseXML, RESPONSE_XML).value = this.internalContext.getIf(RESPONSE_XML).value.get(0).value;
 
         // error post-processing and enrichment (standard messages from keys)
-        let errorData = ErrorData.fromServerError(mergedErrorData);
+        const errorData = ErrorData.fromServerError(mergedErrorData);
 
         // we now trigger an internally stored onError function which might be an attached to the context
         // either we do not have an internal on error, or an on error has been based via params from the outside.
@@ -187,7 +202,7 @@ export class ResponseProcessor implements IResponseProcessor {
     redirect(node: XMLQuery) {
         Assertions.assertUrlExists(node);
 
-        let redirectUrl = trim(node.attr(ATTR_URL).value);
+        const redirectUrl = trim(node.attr(ATTR_URL).value);
         if (redirectUrl != EMPTY_STR) {
             window.location.href = redirectUrl;
         }
@@ -199,8 +214,8 @@ export class ResponseProcessor implements IResponseProcessor {
      * @param cdataBlock the cdata block with the new html code
      */
     update(node: XMLQuery, cdataBlock: string) {
-        let result = ExtDomQuery.byId(node.id.value, true).outerHTML(cdataBlock, false, false);
-        let sourceForm = result?.parents(TAG_FORM).orElseLazy(() => result.byTagName(TAG_FORM, true));
+        const result = ExtDomQuery.byId(node.id.value, true).outerHTML(cdataBlock, false, false);
+        const sourceForm = result?.firstParent(HTML_TAG_FORM).orElseLazy(() => result.byTagName(HTML_TAG_FORM, true));
         if (sourceForm) {
             this.storeForPostProcessing(sourceForm, result);
         }
@@ -220,9 +235,9 @@ export class ResponseProcessor implements IResponseProcessor {
      * @param node
      */
     attributes(node: XMLQuery) {
-        let elem = DQ.byId(node.id.value, true);
+        const elem = DQ.byId(node.id.value, true);
 
-        node.byTagName(TAG_ATTR).each((item: XMLQuery) => {
+        node.byTagName(XML_TAG_ATTR).each((item: XMLQuery) => {
             elem.attr(item.attr(ATTR_NAME).value).value = item.attr(ATTR_VALUE).value;
         });
     }
@@ -243,17 +258,16 @@ export class ResponseProcessor implements IResponseProcessor {
     insert(node: XMLQuery) {
         //let insertId = node.id; //not used atm
 
-        let before = node.attr(TAG_BEFORE);
-        let after = node.attr(TAG_AFTER);
-
-        let insertNodes = DQ.fromMarkup(<any>node.cDATAAsString);
+        const before = node.attr(XML_TAG_BEFORE);
+        const after = node.attr(XML_TAG_AFTER);
+        const insertNodes = DQ.fromMarkup(<any>node.cDATAAsString);
 
         if (before.isPresent()) {
             DQ.byId(before.value, true).insertBefore(insertNodes);
             this.internalContext.assign(UPDATE_ELEMS).value.push(insertNodes);
         }
         if (after.isPresent()) {
-            let domQuery = DQ.byId(after.value, true);
+            const domQuery = DQ.byId(after.value, true);
             domQuery.insertAfter(insertNodes);
 
             this.internalContext.assign(UPDATE_ELEMS).value.push(insertNodes);
@@ -266,12 +280,12 @@ export class ResponseProcessor implements IResponseProcessor {
      * @param node the node hosting the insert data
      */
     insertWithSubTags(node: XMLQuery) {
-        let before = node.querySelectorAll(TAG_BEFORE);
-        let after = node.querySelectorAll(TAG_AFTER);
+        const before = node.querySelectorAll(XML_TAG_BEFORE);
+        const after = node.querySelectorAll(XML_TAG_AFTER);
 
         before.each(item => {
-            let insertId = item.attr(ATTR_ID);
-            let insertNodes = DQ.fromMarkup(<any>item.cDATAAsString);
+            const insertId = item.attr(ATTR_ID);
+            const insertNodes = DQ.fromMarkup(<any>item.cDATAAsString);
             if (insertId.isPresent()) {
                 DQ.byId(insertId.value, true).insertBefore(insertNodes);
                 this.internalContext.assign(UPDATE_ELEMS).value.push(insertNodes);
@@ -279,8 +293,8 @@ export class ResponseProcessor implements IResponseProcessor {
         });
 
         after.each(item => {
-            let insertId = item.attr(ATTR_ID);
-            let insertNodes = DQ.fromMarkup(<any>item.cDATAAsString);
+            const insertId = item.attr(ATTR_ID);
+            const insertNodes = DQ.fromMarkup(<any>item.cDATAAsString);
             if (insertId.isPresent()) {
                 DQ.byId(insertId.value, true).insertAfter(insertNodes);
                 this.internalContext.assign(UPDATE_ELEMS).value.push(insertNodes);
@@ -295,7 +309,7 @@ export class ResponseProcessor implements IResponseProcessor {
      */
     processViewState(node: XMLQuery): boolean {
         if (ResponseProcessor.isViewStateNode(node)) {
-            let state = node.cDATAAsString;
+            const state = node.cDATAAsString;
             this.internalContext.assign(APPLIED_VST, node.id.value).value = new StateHolder($nsp(node.id.value), state);
             return true;
         }
@@ -304,7 +318,7 @@ export class ResponseProcessor implements IResponseProcessor {
 
     processClientWindow(node: XMLQuery): boolean {
         if (ResponseProcessor.isClientWindowNode(node)) {
-            let state = node.cDATAAsString;
+            const state = node.cDATAAsString;
             this.internalContext.assign(APPLIED_CLIENT_WINDOW, node.id.value).value = new StateHolder($nsp(node.id.value), state);
             return true;
         }
@@ -333,40 +347,54 @@ export class ResponseProcessor implements IResponseProcessor {
      */
     fixViewStates() {
         Stream.ofAssoc<StateHolder>(this.internalContext.getIf(APPLIED_VST).orElse({}).value)
-            .each((item: Array<any>) => {
-                let value: StateHolder = item[1];
-                let nameSpace = DQ.byId(value.nameSpace, true).orElse(document.body);
-                let affectedForms = nameSpace.byTagName(TAG_FORM);
-                let affectedForms2 = nameSpace.filter(item => item.tagName.orElse(EMPTY_STR).value.toLowerCase() == TAG_FORM);
+            .each(([, value]) => {
+                const namingContainerId = this.internalContext.getIf(NAMING_CONTAINER_ID);
+                const namedViewRoot = !!this.internalContext.getIf(NAMED_VIEWROOT).value
+                const affectedForms = this.getContainerForms(namingContainerId)
+                    .filter(affectedForm => this.isInExecuteOrRender(affectedForm));
 
-                this.appendViewStateToForms(new DomQuery(affectedForms, affectedForms2), value.value);
+                this.appendViewStateToForms(affectedForms, namedViewRoot, value.value, namingContainerId.orElse("").value);
             });
     }
 
+
+
     /**
      * same as with view states before applies the incoming client windows as last step after the rest of the processing
      * is done.
      */
     fixClientWindow() {
         Stream.ofAssoc<StateHolder>(this.internalContext.getIf(APPLIED_CLIENT_WINDOW).orElse({}).value)
-            .each((item: Array<any>) => {
-                let value: StateHolder = item[1];
-                let nameSpace = DQ.byId(value.nameSpace, true).orElse(document.body);
-                let affectedForms = nameSpace.byTagName(TAG_FORM);
-                let affectedForms2 = nameSpace.filter(item => item.tagName.orElse(EMPTY_STR).value.toLowerCase() == TAG_FORM);
+            .each(([, value]) => {
+                const namingContainerId = this.internalContext.getIf(NAMING_CONTAINER_ID);
+                const namedViewRoot = !!this.internalContext.getIf(NAMED_VIEWROOT).value;
+                const affectedForms = this.getContainerForms(namingContainerId)
+                    .filter(affectedForm => this.isInExecuteOrRender(affectedForm));
 
-                this.appendClientWindowToForms(new DomQuery(affectedForms, affectedForms2), value.value);
+                this.appendClientWindowToForms(affectedForms, namedViewRoot, value.value, namingContainerId.orElse("").value);
             });
     }
 
+    updateNamedViewRootState() {
+        let partialId = this.internalContext.getIf(NAMING_CONTAINER_ID);
+        let namedViewRoot = this.internalContext.getIf(NAMED_VIEWROOT);
+        if(partialId.isPresent() &&
+            (namedViewRoot.isAbsent() ||
+                !namedViewRoot.value)) {
+            const SEP = $faces().separatorchar;
+            this.internalContext.assign(NAMED_VIEWROOT).value = (!!document.getElementById(partialId.value)) || DQ$(`input[name*='${$nsp(P_VIEWSTATE)}']`)
+                .filter(node => node.attr("name").value.indexOf(partialId.value + SEP) == 0).length > 0;
+        }
+    }
+
     /**
      * all processing done we can close the request and send the appropriate events
      */
     done() {
-        let eventData = EventData.createFromRequest(this.request.value, this.externalContext, SUCCESS);
+        const eventData = EventData.createFromRequest(this.request.value, this.externalContext, SUCCESS);
 
         //because some frameworks might decorate them over the context in the response
-        let eventHandler = this.externalContext.getIf(ON_EVENT).orElseLazy(() => this.internalContext.getIf(ON_EVENT).value).orElse(EMPTY_FUNC).value;
+        const eventHandler = this.externalContext.getIf(ON_EVENT).orElseLazy(() => this.internalContext.getIf(ON_EVENT).value).orElse(EMPTY_FUNC).value;
         Implementation.sendEvent(eventData, eventHandler);
     }
 
@@ -375,9 +403,10 @@ export class ResponseProcessor implements IResponseProcessor {
      *
      * @param forms the forms to append the viewState to
      * @param viewState the final viewState
+     * @param namingContainerId
      */
-    private appendViewStateToForms(forms: DQ, viewState: string) {
-        this.assignState(forms, $nsp(SEL_VIEWSTATE_ELEM), viewState);
+    private appendViewStateToForms(forms: DQ, namedViewRoot: boolean, viewState: string, namingContainerId = "") {
+        this.assignState(forms, $nsp(SEL_VIEWSTATE_ELEM), namedViewRoot, viewState, namingContainerId);
     }
 
 
@@ -386,9 +415,10 @@ export class ResponseProcessor implements IResponseProcessor {
      *
      * @param forms the forms to append the viewState to
      * @param clientWindow the final viewState
+     * @param namingContainerId
      */
-    private appendClientWindowToForms(forms: DQ, clientWindow: string) {
-        this.assignState(forms, $nsp(SEL_CLIENT_WINDOW_ELEM), clientWindow);
+    private appendClientWindowToForms(forms: DQ, namedViewRoot: boolean, clientWindow: string, namingContainerId = "") {
+        this.assignState(forms, $nsp(SEL_CLIENT_WINDOW_ELEM), namedViewRoot, clientWindow, namingContainerId);
     }
 
     /**
@@ -396,31 +426,32 @@ export class ResponseProcessor implements IResponseProcessor {
      *
      * @param forms the forms to append or change to
      * @param selector the selector for the state
+     * @param namedViewRoot if set to true, the name is also prefixed
      * @param state the state itself which needs to be assigned
      *
+     * @param namingContainerId
      * @private
      */
-    private assignState(forms: DQ, selector: string, state: string) {
-        forms.each((form: DQ) => {
-            let stateHolders = form.querySelectorAll(selector)
-                .orElseLazy(() => ResponseProcessor.newViewStateElement(form));
-
-            stateHolders.attr("value").value = state;
+    private assignState(forms: DQ,  selector: string, namedViewRoot: boolean, state: string, namingContainerId: string) {
+        /**
+         * creates the viewState or client window id element
+         * @param form
+         */
+        const createAndAppendHiddenInput = (form: DomQuery)  => {
+            return new HiddenInputBuilder(selector)
+                .withNamingContainerId(namingContainerId)
+                .withParent(form)
+                .withNamedViewRoot(namedViewRoot)
+                .build();
+        };
+
+        forms.each(form => {
+            const hiddenInput = form.querySelectorAll(selector)
+                .orElseLazy(() => createAndAppendHiddenInput(form));
+            hiddenInput.val = state;
         });
     }
 
-    /**
-     * Helper to Create a new JSF ViewState Element
-     *
-     * @param parent, the parent node to attach the viewState element to
-     * (usually a form node)
-     */
-    private static newViewStateElement(parent: DQ): DQ {
-        let newViewState = DQ.fromMarkup($nsp(HTML_VIEWSTATE));
-        newViewState.appendTo(parent);
-        return newViewState;
-    }
-
     /**
      * Stores certain aspects of the dom for later post-processing
      *
@@ -457,10 +488,10 @@ export class ResponseProcessor implements IResponseProcessor {
      * @returns if it is a viewState node
      */
     private static isViewStateNode(node: XMLQuery): boolean {
-        let separatorChar = (window?.faces ?? window?.jsf).separatorchar;
+        const SEP = $faces().separatorchar;
         return "undefined" != typeof node?.id?.value && (node?.id?.value == $nsp(P_VIEWSTATE) ||
-            node?.id?.value?.indexOf([separatorChar, $nsp(P_VIEWSTATE)].join(EMPTY_STR)) != -1 ||
-            node?.id?.value?.indexOf([$nsp(P_VIEWSTATE), separatorChar].join(EMPTY_STR)) != -1);
+            node?.id?.value?.indexOf([SEP, $nsp(P_VIEWSTATE)].join(EMPTY_STR)) != -1 ||
+            node?.id?.value?.indexOf([$nsp(P_VIEWSTATE), SEP].join(EMPTY_STR)) != -1);
     }
 
     /**
@@ -470,15 +501,59 @@ export class ResponseProcessor implements IResponseProcessor {
      * @returns true of it ii
      */
     private static isClientWindowNode(node: XMLQuery): boolean {
-        let separatorChar = (window?.faces ?? window?.jsf).separatorchar;
+        const SEP =  $faces().separatorchar;
         return "undefined" != typeof node?.id?.value && (node?.id?.value == $nsp(P_CLIENT_WINDOW) ||
-            node?.id?.value?.indexOf([separatorChar, $nsp(P_CLIENT_WINDOW)].join(EMPTY_STR)) != -1 ||
-            node?.id?.value?.indexOf([$nsp(P_CLIENT_WINDOW), separatorChar].join(EMPTY_STR)) != -1);
+            node?.id?.value?.indexOf([SEP, $nsp(P_CLIENT_WINDOW)].join(EMPTY_STR)) != -1 ||
+            node?.id?.value?.indexOf([$nsp(P_CLIENT_WINDOW), SEP].join(EMPTY_STR)) != -1);
     }
 
     private triggerOnError(errorData: ErrorData) {
-        this.externalContext.getIf(ON_ERROR).orElse(this.internalContext.getIf(ON_ERROR).value).orElse(EMPTY_FUNC).value(errorData);
+        this.externalContext.getIf(ON_ERROR).orElseLazy(() => this.internalContext.getIf(ON_ERROR).value).orElse(EMPTY_FUNC).value(errorData);
+    }
+
+    /**
+     * filters the forms according to being member of the "execute" or "render" cycle
+     * @param affectedForm
+     * @private
+     */
+    private isInExecuteOrRender(affectedForm) {
+        const executes = this.externalContext.getIf($nsp(P_EXECUTE)).orElse("@none").value.split(/\s+/gi);
+        const renders = this.externalContext.getIf(P_RENDER_OVERRIDE)
+            .orElseLazy(() => this.externalContext.getIf($nsp(P_RENDER)).value)
+            .orElse(IDENT_NONE).value.split(/\s+/gi);
+        const executeAndRenders = executes.concat(...renders);
+        return LazyStream.of(...executeAndRenders).filter(nameOrId => {
+            if ([IDENT_ALL, IDENT_NONE].indexOf(nameOrId) != -1) {
+                return true;
+            }
+
+            const NAME_OR_ID = this.getNameOrIdSelector(nameOrId);
+            //either the form directly is in execute or render or one of its children or one of its parents
+            return affectedForm.matchesSelector(NAME_OR_ID) ||
+                affectedForm.querySelectorAll(NAME_OR_ID).isPresent() ||
+                affectedForm.firstParent(NAME_OR_ID).isPresent();
+        }).first().isPresent();
     }
 
+    /**
+     * gets all forms under a single naming container id
+     * @param namingContainerId
+     * @private
+     */
+    private getContainerForms(namingContainerId: Config) {
+        if (namingContainerId.isPresent()) {
+            //naming container mode, all forms under naming container id must be processed
+            return DQ$(this.getNameOrIdSelector(namingContainerId.value))
+                // missing condition if the naming container is not present we have to
+                // use the body as fallback
+                .orElseLazy(() => DQ.byTagName(HTML_TAG_BODY))
+                .byTagName(HTML_TAG_FORM, true);
+        } else {
+            return DQ.byTagName(HTML_TAG_FORM);
+        }
+    }
 
+    private getNameOrIdSelector(nameOrId) {
+        return `[id='${nameOrId}'], [name='${nameOrId}']`;
+    }
 }