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

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

@@ -14,14 +14,17 @@
  * limitations under the License.
  */
 
-import {AssocArrayCollector, Config, DomQuery, DQ, Stream} from "mona-dish";
+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,
+    P_VIEWSTATE,
     REQ_TYPE_GET,
     REQ_TYPE_POST
 } from "../core/Const";
@@ -69,20 +72,26 @@ 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];
+    if(viewId.indexOf($nsp(P_VIEWSTATE)) === -1) {
+        return viewId;
+    }
+    return "";
 }
 
 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);
 }
 
 /**
@@ -91,14 +100,12 @@ 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;
-
-    // null or non undefined will automatically be mapped to 0 aka no delay
-    let ret = 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
-    if('none' === ret) {
-        ret = 0;
-    }
+    ret = (DELAY_NONE === ret) ? 0 : ret;
     // negative, or invalid values will automatically get a js exception
     Assertions.assertDelay(ret);
     return ret;
@@ -148,14 +155,15 @@ export function getEventTarget(evt: Event): Element {
  * @param opts
  * @param el
  */
-export function resolveDefaults(event: Event, opts: Options | [[string, 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
@@ -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.firstParent(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,
+    XML_TAG_PARTIAL_RESP,
     RESPONSE_XML,
-    TAG_AFTER,
-    TAG_BEFORE
+    XML_TAG_AFTER,
+    XML_TAG_BEFORE
 } 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.
@@ -89,18 +89,18 @@ export module Response {
      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(",");
+        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;
             }
@@ -110,7 +110,7 @@ export module Response {
 
     let processInsert = function (responseProcessor: IResponseProcessor, node: XMLQuery) {
          // path1 insert after as child tags
-         if(node.querySelectorAll([TAG_BEFORE, TAG_AFTER].join(",")).length) {
+         if(node.querySelectorAll([XML_TAG_BEFORE, XML_TAG_AFTER].join(",")).length) {
              responseProcessor.insertWithSubTags(node);
          } else { // insert before after with id
              responseProcessor.insert(node);
@@ -125,31 +125,31 @@ export module Response {
      * @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(", ");
+        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;
                 }
             }