jsf.js_next_gen 4.0.0-beta-23 → 4.0.1-alpha.0

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

@@ -16,18 +16,23 @@
 
 import {Config, DomQuery, DQ} from "mona-dish";
 import {
-    CTX_PARAM_DELAY,
-    CTX_PARAM_TIMEOUT,
+    $faces,
+    $nsp,
+    CTX_OPTIONS_DELAY,
+    CTX_OPTIONS_TIMEOUT,
+    DELAY_NONE,
     EMPTY_FUNC,
     EMPTY_STR,
-    ENCODED_URL,
-    MF_NONE,
+    ENCODED_URL, NAMED_VIEWROOT, NAMING_CONTAINER_ID,
+    P_VIEWSTATE,
     REQ_TYPE_GET,
     REQ_TYPE_POST
 } from "../core/Const";
 import {XhrFormData} from "./XhrFormData";
 import {ExtLang} from "../util/Lang";
-import {ExtConfig, ExtDomquery} from "../util/ExtDomQuery";
+import {ExtConfig, ExtDomQuery} from "../util/ExtDomQuery";
+import {Assertions} from "../util/Assertions";
+
 
 /**
  * Resolver functions for various aspects of the request data
@@ -37,7 +42,7 @@ import {ExtConfig, ExtDomquery} from "../util/ExtDomQuery";
  */
 
 /**
- * resolves the event handlers lazly
+ * resolves the event handlers lazily
  * so that if some decoration happens in between we can deal with it
  *
  * @param requestContext
@@ -45,6 +50,7 @@ import {ExtConfig, ExtDomquery} from "../util/ExtDomQuery";
  * @param funcName
  */
 export function resolveHandlerFunc(requestContext: Config, responseContext: Config, funcName: string) {
+    responseContext = responseContext || new Config({});
     return responseContext.getIf(funcName)
         .orElseLazy(() =>requestContext.getIf(funcName).value)
         .orElse(EMPTY_FUNC).value;
@@ -67,20 +73,52 @@ export function resolveFinalUrl(sourceForm: DomQuery, formData: XhrFormData, aja
  * it is either the id or the parent form of the element or an embedded form
  * of the element
  *
- * @param requestCtx
  * @param elem
  * @param event
  */
-export function resolveForm(requestCtx: Config, elem: DQ, event: Event): DQ {
-    const configId = requestCtx.value?.myfaces?.form ?? MF_NONE;
-    return DQ
-        .byId(configId, true)
-        .orElseLazy(() => ExtLang.getForm(elem.getAsElem(0).value, event));
+export function resolveForm(elem: DQ, event: Event): DQ {
+    return ExtLang.getForm(elem.getAsElem(0).value, event);
+}
+
+export function resolveViewId(form: DQ): string {
+    const viewState = form.querySelectorAll(`input[type='hidden'][name*='${$nsp(P_VIEWSTATE)}']`).id.orElse("").value;
+    const divider = $faces().separatorchar;
+    const viewId = viewState.split(divider, 2)[0];
+    const viewStateViewId = viewId.indexOf($nsp(P_VIEWSTATE)) === -1 ? viewId : "";
+    // myfaces specific, we in non portlet environments prepend the viewId
+    // even without being in a naming container, the other components ignore that
+    return form.id.value.indexOf(viewStateViewId) === 0 ? viewStateViewId : "";
+}
+
+export function resolveViewRootId(form: DQ): string {
+    const viewState = form.querySelectorAll(`input[type='hidden'][name*='${$nsp(P_VIEWSTATE)}']`).attr("name").orElse("").value;
+    const divider = $faces().separatorchar;
+    const viewId = viewState.split(divider, 2)[0];
+    //different to the identifier the form id is never prepended to the viewstate
+    return viewId.indexOf($nsp(P_VIEWSTATE)) === -1 ? viewId : "";
+}
+
+/**
+ * as per jsdoc before the request it must be ensured that every post argument
+ * is prefixed with the naming container id (there is an exception in mojarra with
+ * the element=element param, which we have to follow here as well.
+ * (inputs are prefixed by name anyway normally this only affects our standard parameters)
+ * @private
+ */
+export function resoveNamingContainerMapper(internalContext: Config): (key: string, value: any) => [string, any] {
+    const isNamedViewRoot = internalContext.getIf(NAMED_VIEWROOT).isPresent();
+    if(!isNamedViewRoot) {
+        return (key, value) => [key, value];
+    }
+    const partialId = internalContext.getIf(NAMING_CONTAINER_ID).value;
+    const SEP = $faces().separatorchar;
+    const prefix = partialId + SEP;
+    return (key: string, value: any) => (key.indexOf(prefix) == 0) ? [key, value] : [prefix + key, value];
 }
 
 export function resolveTimeout(options: Config): number {
     let getCfg = ExtLang.getLocalOrGlobalConfig;
-    return options.getIf(CTX_PARAM_TIMEOUT).value ?? getCfg(options.value, CTX_PARAM_TIMEOUT, 0);
+    return options.getIf(CTX_OPTIONS_TIMEOUT).value ?? getCfg(options.value, CTX_OPTIONS_TIMEOUT, 0);
 }
 
 /**
@@ -89,18 +127,24 @@ export function resolveTimeout(options: Config): number {
  * @param options ... the options object, in most cases it will host the delay value
  */
 export function resolveDelay(options: Config): number {
-    let getCfg = ExtLang.getLocalOrGlobalConfig;
-
-    return options.getIf(CTX_PARAM_DELAY).value ?? getCfg(options.value, CTX_PARAM_DELAY, 0);
+    // null, 'none', or undefined will automatically be mapped to 0 aka no delay
+    // the config delay will be dropped not needed anymore, it does not really
+    // make sense anymore now that it is part of a local spec
+    let ret = options.getIf(CTX_OPTIONS_DELAY).orElse(0).value;
+    // if delay === none, no delay must be used, aka delay 0
+    ret = (DELAY_NONE === ret) ? 0 : ret;
+    // negative, or invalid values will automatically get a js exception
+    Assertions.assertDelay(ret);
+    return ret;
 }
 
 /**
- * resolves the window Id from various sources
+ * resolves the window-id from various sources
  *
  * @param options
  */
 export function resolveWindowId(options: Config) {
-    return options?.value?.windowId ?? ExtDomquery.windowId;
+    return options?.value?.windowId ?? ExtDomQuery.windowId;
 }
 
 /**
@@ -108,19 +152,20 @@ export function resolveWindowId(options: Config) {
  * browser save event resolution
  * @param evt the event object
  * (with a fallback for ie events if none is present)
+ * @deprecated soon will be removed
  */
 export function getEventTarget(evt: Event): Element {
-    //ie6 and 7 fallback
+    // ie6 and 7 fallback
     let finalEvent = evt;
-    /**
+    /*
      * evt source is defined in the jsf events
-     * seems like some component authors use our code
+     * seems like some component authors use our code,
      * so we add it here see also
      * https://issues.apache.org/jira/browse/MYFACES-2458
      * not entirely a bug but makes sense to add this
-     * behavior. I dont use it that way but nevertheless it
+     * behavior. I don´t use it that way but nevertheless it
      * does not break anything so why not
-     * */
+     */
     let t = finalEvent?.srcElement ?? finalEvent?.target ?? (<any>finalEvent)?.source;
     while ((t) && (t.nodeType != 1)) {
         t = t.parentNode;
@@ -137,14 +182,15 @@ export function getEventTarget(evt: Event): Element {
  * @param opts
  * @param el
  */
-export function resolveDefaults(event: Event, opts: any = {}, el: Element | string = null) {
+export function resolveDefaults(event: Event, opts: Options | [[string, any]] , el: Element | string = null): any {
     //deep copy the options, so that further transformations to not backfire into the callers
-    const resolvedEvent = event,
-        options = new ExtConfig(opts).deepCopy,
-        elem = DQ.byId(el || <Element>resolvedEvent.target, true),
-        elementId = elem.id.value, requestCtx = new ExtConfig({}),
-        internalCtx = new ExtConfig({}), windowId = resolveWindowId(options),
-        isResetValues = true === options.value?.resetValues;
-
-    return {resolvedEvent, options, elem, elementId, requestCtx, internalCtx, windowId, isResetValues};
+    const elem = DQ.byId(el || <Element>event.target, true);
+    const options = new ExtConfig(opts).deepCopy as ExtConfig;
+    return {
+        options: options,
+        elem: elem,
+        elementId: elem.id.value,
+        windowId: resolveWindowId(options),
+        isResetValues: true === options.value?.resetValues
+    };
 }

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

@@ -25,7 +25,7 @@ import {
     CTX_PARAM_SRC_FRM_ID,
     SEL_RESPONSE_XML,
     SOURCE,
-    TAG_FORM,
+    HTML_TAG_FORM,
     UPDATE_ELEMS,
     UPDATE_FORMS,
     DEFERRED_HEAD_INSERTS
@@ -45,7 +45,7 @@ import {ExtConfig} from "../util/ExtDomQuery";
  *
  * @param request the request hosting the responseXML
  *
- * Throws an error in case of non existent or wrong xml data
+ * Throws an error in case of non-existent or wrong xml data
  *
  */
 export function resolveResponseXML(request: Config): XMLQuery {
@@ -56,8 +56,8 @@ export function resolveResponseXML(request: Config): XMLQuery {
 }
 
 /**
- * Splits the incoming passthrough context apart
- * in an internal and an external nomalized context
+ * Splits the incoming pass-through context apart
+ * in an internal and an external normalized context
  * the internal one is just for our internal processing
  *
  * @param context the root context as associative array
@@ -83,10 +83,10 @@ export function resolveContexts(context: { [p: string]: any }): any {
 }
 
 /**
- * fetches the source element out of our conexts
+ * fetches the source element out of our contexts
  *
- * @param context the external context which shpuld host the source id
- * @param internalContext internal passthrough fall back
+ * @param context the external context which should host the source id
+ * @param internalContext internal pass-through fall back
  *
  */
 export function resolveSourceElement(context: Config, internalContext: Config): DQ {
@@ -106,9 +106,9 @@ export function resolveSourceForm(internalContext: Config, elem: DQ): DQ {
     let sourceFormId = internalContext.getIf(CTX_PARAM_SRC_FRM_ID);
     let sourceForm = new DQ(sourceFormId.isPresent() ? document.forms[sourceFormId.value] : null);
 
-    sourceForm = sourceForm.orElseLazy(() => elem.parents(TAG_FORM))
-        .orElseLazy(() => elem.querySelectorAll(TAG_FORM))
-        .orElseLazy(() => DQ.querySelectorAll(TAG_FORM));
+    sourceForm = sourceForm.orElseLazy(() => elem.firstParent(HTML_TAG_FORM))
+        .orElseLazy(() => elem.querySelectorAll(HTML_TAG_FORM))
+        .orElseLazy(() => DQ.querySelectorAll(HTML_TAG_FORM));
 
     return sourceForm;
 }

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";
@@ -66,16 +66,17 @@ 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)
+        // we now process the partial tags, or in none given raise an error
+        responseXML.querySelectorAll(XML_TAG_PARTIAL_RESP)
             .each(item => processPartialTag(<XMLQuery>item, responseProcessor, internalContext));
 
-        //we now process the viewstates, client windows and the evals deferred
-        //the reason for this is that often it is better
-        //to wait until the document has caught up before
-        //doing any evals 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
+        // We now process the viewStates, client windows and the elements to be evaluated are delayed.
+        // The reason for this is that often it is better
+        // to wait until the document has caught up before
+        // 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(",");
 
-        //now we can process the main operations
+        /*
+        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;
                 }
             }
@@ -171,14 +188,14 @@ export module Response {
 
     /**
      * branch tag update. drill further down into the updates
-     * special case viewstate in that case it is a leaf
-     * and the viewstate must be processed
+     * special case viewState in that case it is a leaf
+     * and the viewState must be processed
      *
      * @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) :
@@ -209,7 +226,7 @@ export module Response {
                 responseProcessor.addToHead(DQ.fromMarkup(cdataBlock))
                 break;
 
-            default://htmlItem replacement
+            default:// htmlItem replacement
                 responseProcessor.update(node, cdataBlock);
                 break;
         }