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

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

@@ -16,9 +16,6 @@
 import {Config, Lang, XMLQuery} from "mona-dish";
 
 import {DQ} from "mona-dish";
-import {ExtLang} from "./Lang";
-import getMessage = ExtLang.getMessage;
-import makeException = ExtLang.makeException;
 import {
     ATTR_URL,
     EMPTY_RESPONSE,
@@ -26,8 +23,10 @@ import {
     ON_ERROR,
     ON_EVENT,
     PHASE_PROCESS_RESPONSE,
-    RESP_PARTIAL
+    XML_TAG_PARTIAL_RESP
 } from "../core/Const";
+import {ExtLang} from "./Lang";
+
 
 /**
  * a set of internal code assertions
@@ -36,6 +35,8 @@ import {
  */
 export module Assertions {
 
+
+
     export function assertRequestIntegrity(options: Config, elem: DQ): void | never {
         /*assert if the onerror is set and once if it is set it must be of type function*/
         assertFunction(options.getIf(ON_ERROR).value);
@@ -43,12 +44,12 @@ export module Assertions {
         assertFunction(options.getIf(ON_EVENT).value);
         //improve the error messages if an empty elem is passed
         //Assertions.assertElementExists(elem);
-        assert(elem.isPresent(), getMessage("ERR_MUST_BE_PROVIDED1", "{0}: source  must be provided or exist", "source element id"), "faces.ajax.request", "ArgNotSet",  )
+        assert(elem.isPresent(), ExtLang.getMessage("ERR_MUST_BE_PROVIDED1", "{0}: source  must be provided or exist", "source element id"), "faces.ajax.request", "ArgNotSet",  )
     }
 
     export function assertUrlExists(node: XMLQuery): void | never {
         if (node.attr(ATTR_URL).isAbsent()) {
-            throw Assertions.raiseError(new Error(), getMessage("ERR_RED_URL", null, "processRedirect"), "processRedirect");
+            throw Assertions.raiseError(new Error(), ExtLang.getMessage("ERR_RED_URL", null, "processRedirect"), "processRedirect");
         }
     }
 
@@ -59,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);
     }
 
     /**
@@ -79,7 +80,7 @@ export module Assertions {
         let finalMessage = message ?? EMPTY_STR;
 
         //TODO clean up the messy makeException, this is a perfect case for encapsulation and sane defaults
-        return makeException(error, finalTitle, finalName, "Response", caller || (((<any>arguments).caller) ? (<any>arguments).caller.toString() : "_raiseError"), finalMessage);
+        return ExtLang.makeException(error, finalTitle, finalName, "Response", caller || (((<any>arguments).caller) ? (<any>arguments).caller.toString() : "_raiseError"), finalMessage);
     }
 
     /*
@@ -103,6 +104,13 @@ export module Assertions {
     export function assertFunction(value: any, msg = EMPTY_STR, caller=EMPTY_STR, title="Assertion Error"): asserts value is Function {
         assertType(value, "function", msg, caller, title);
     }
+
+    export function assertDelay(value: any) {
+        if(!(value >= 0)) { // >= 0 abbreviation which covers all cases of non positive values,
+            // including NaN and non numeric strings, no type equality is deliberate here,
+            throw new Error("Invalid delay value: " + value);
+        }
+    }
 }
 
 

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;
@@ -235,7 +235,7 @@ export class ExtDomQuery extends DQ {
      * @param deep whether the search should go into embedded shadow dom elements
      * @return a DomQuery containing the found elements
      */
-    static byId(selector: string | DomQuery | Element, deep = false): DomQuery {
+    static byId(selector: string | DomQuery | Element, deep = false): ExtDomQuery {
         const ret = DomQuery.byId(selector, deep);
         return new ExtDomQuery(ret);
     }
@@ -244,6 +244,9 @@ export class ExtDomQuery extends DQ {
         return (curScript.getAsElem(0).value as HTMLElement)?.nonce ?? curScript.attr("nonce").value;
     }
 
+    filter(func: (item: DomQuery) => boolean): ExtDomQuery {
+        return new ExtDomQuery(super.filter(func));
+    }
 }
 
 export const ExtDQ = ExtDomQuery;
@@ -254,6 +257,8 @@ export const ExtDQ = ExtDomQuery;
  */
 export class ExtConfig extends  Config {
 
+    $nspEnabled = true;
+
     constructor(root: any) {
         super(root);
     }
@@ -323,7 +328,10 @@ export class ExtConfig extends  Config {
      * @param accessPath the access paths to be remapped
      * @private returns an array of access paths with version remapped namespaces
      */
-    private remap(accessPath: any[]) {
+    private remap(accessPath: string[]): string[] {
+        if(!this.$nspEnabled) {
+            return accessPath;
+        }
         return Stream.of(...accessPath).map(key => $nsp(key)).collect(new ArrayCollector());
     }
 }

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

@@ -0,0 +1,89 @@
+/*! 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 namedViewRoot: boolean = false;
+    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;
+    }
+
+    withNamedViewRoot(namedViewRoot: boolean): HiddenInputBuilder {
+        this.namedViewRoot = namedViewRoot;
+        return this;
+    }
+
+
+    build(): DomQuery {
+        const SEP = $faces().separatorchar;
+
+        let existingStates = DQ$(`[name*='${$nsp(this.name)}']`);
+        let cnt = existingStates.stream.map(state => {
+            let ident: string = state.id.orElse("-1").value;
+            ident = ident.substring(ident.lastIndexOf(SEP)+1);
+            return parseInt(ident);
+        })
+            .filter(item => !isNaN(item))
+            .reduce((item1, item2) => Math.max(item1, item2), -1).value;
+        //the maximum  new ident is the current max + 1
+        cnt++;
+
+
+        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);
+
+        //name must be prefixed with the naming container id as well according to the jsdocs
+        if(this.namedViewRoot) {
+            newElement.name.value = (this.namingContainerId?.length) ?
+                [this.namingContainerId,  $nsp(this.name)].join(SEP): $nsp(this.name);
+        } else {
+            newElement.name.value = $nsp(this.name);
+        }
+
+
+        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";
 
 
@@ -160,25 +158,25 @@ export module ExtLang {
     export function getForm(elem: Element, event ?: Event): DQ | never {
 
         let queryElem = new DQ(elem);
-        let eventTarget = new DQ(getEventTarget(event));
+        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.parents(TAG_FORM)
-            .orElseLazy(() => queryElem.byTagName(TAG_FORM, true))
-            .orElseLazy(() => eventTarget.parents(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/util/URLCodec.ts

@@ -0,0 +1,71 @@
+import {ArrayCollector, Config, LazyStream, Stream} from "mona-dish";
+import {ExtConfig, ExtDomQuery} from "./ExtDomQuery";
+import {EMPTY_STR} from "../core/Const";
+
+/*
+ * various routines for encoding and decoding url parameters
+ * into configs and vice versa
+ */
+
+/**
+ * merges a list of key value entries into a target config
+ * @param target the target receiving the key value entries
+ * @param keyValueEntries a list of key value entries divided by =
+ * @param paramsMapper a key value remapper
+ */
+export function mergeKeyValueEntries(target: Config, keyValueEntries: string[], paramsMapper = (key, value) => [key, value]) {
+
+    function splitToKeyVal(line: string) {
+        return line.split(/=(.*)/gi);
+    }
+
+    function fixKeyWithoutVal(keyVal: string[]) {
+        return keyVal.length < 3 ? [keyVal?.[0] ?? [], keyVal?.[1] ?? []] : keyVal;
+    }
+
+    let toMerge = new ExtConfig({});
+    Stream.of(...keyValueEntries)
+        .map(line => splitToKeyVal(line))
+        //special case of having keys without values
+        .map(keyVal => fixKeyWithoutVal(keyVal))
+        .map(keyVal => paramsMapper(keyVal[0] as string, keyVal[1]))
+        .each(keyVal => {
+            toMerge.append(keyVal[0] as string).value = keyVal?.splice(1)?.join("") ?? "";
+        });
+
+    target.shallowMerge(toMerge);
+}
+
+/**
+ * encodes a given form data into a url encoded string
+ * @param formData the form data config object
+ * @param paramsMapper the params mapper
+ * @param defaultStr a default string if nothing comes out of it
+ */
+export function encodeFormData(formData: Config,
+                               paramsMapper = (inStr, inVal) => [inStr, inVal],
+                               defaultStr = EMPTY_STR): string {
+    if (formData.isAbsent()) {
+        return defaultStr;
+    }
+    let assocValues = formData.value;
+    let entries = LazyStream.of(...Object.keys(assocValues))
+        .filter(key => assocValues.hasOwnProperty(key))
+        .flatMap(key => Stream.of(...assocValues[key]).map(val => paramsMapper(key, val)))
+        //we cannot encode file elements that is handled by multipart requests anyway
+        .filter(([, value]) => !(value instanceof ExtDomQuery.global().File))
+        .map(keyVal => `${encodeURIComponent(keyVal[0])}=${encodeURIComponent(keyVal[1])}`)
+        .collect(new ArrayCollector());
+
+    return entries.join("&")
+}
+
+/**
+ * splits and decodes encoded values into strings containing of key=value
+ * @param encoded encoded string
+ */
+export function decodeEncodedValues(encoded: string): string[] {
+    return decodeURIComponent(encoded).split(/&/gi)
+        .filter(item => !!(item || '')
+            .replace(/\s+/g, ''));
+}

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

@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 import {
-    EMPTY_STR,
+    EMPTY_STR, ERROR,
     ERROR_MESSAGE,
     ERROR_NAME,
     RESPONSE_TEXT,
-    RESPONSE_XML,
+    RESPONSE_XML, SERVER_ERROR,
     SOURCE,
     STATUS,
     UNKNOWN
@@ -49,7 +49,8 @@ export enum ErrorType {
 export class ErrorData extends EventData implements IErrorData {
 
     type: string = "error";
-    source: string;
+    source: HTMLElement;
+    sourceId: string;
     errorName: string;
     errorMessage: string;
 
@@ -63,12 +64,14 @@ export class ErrorData extends EventData implements IErrorData {
     serverErrorMessage: string;
     message: string;
 
-    constructor(source: string, errorName: string, errorMessage: string, responseText: string = null, responseXML: any = null, responseCode: string = "200", status: string = "UNKNOWN", type = ErrorType.CLIENT_ERROR) {
+    constructor(source: string, errorName: string, errorMessage: string, responseText: string = null, responseXML: any = null, responseCode: string = "200", status: string = "", type = ErrorType.CLIENT_ERROR) {
         super();
-        this.source = source;
-        this.type = "error";
+        this.source = document.getElementById(source);
+        this.sourceId = source;
+        this.type = ERROR;
         this.errorName = errorName;
-        this.message = this.errorMessage = errorMessage;
+        //tck requires that the type is prefixed to the message itself (jsdoc also) in case of a server error
+        this.message = this.errorMessage = (type == SERVER_ERROR) ? type + ": " + errorMessage : errorMessage;
         this.responseCode = responseCode;
         this.responseText = responseText;
         this.status = status;
@@ -81,10 +84,10 @@ export class ErrorData extends EventData implements IErrorData {
     }
 
     static fromClient(e: Error): ErrorData {
-        return new ErrorData("client", e?.name ?? '', e?.message ?? '', e?.stack ?? '');
+        return new ErrorData((e as any)?.source ?? "client", e?.name ?? EMPTY_STR, e?.message ?? EMPTY_STR, e?.stack ?? EMPTY_STR);
     }
 
-    static fromHttpConnection(source: any, name: string, message: string, responseText, responseCode: number, status: string = 'UNKNOWN'): ErrorData {
+    static fromHttpConnection(source: any, name: string, message: string, responseText, responseCode: number, status: string = EMPTY_STR): ErrorData {
         return new ErrorData(source, name, message, responseText, responseCode, `${responseCode}`, status, ErrorType.HTTP_ERROR);
     }
 
@@ -98,11 +101,13 @@ export class ErrorData extends EventData implements IErrorData {
         let status = getMsg(context, STATUS);
         let responseText = getMsg(context, RESPONSE_TEXT);
         let responseXML = getMsg(context, RESPONSE_XML);
+
+
         return new ErrorData(source, errorName, errorMessage, responseText, responseXML, errorCode + EMPTY_STR, status, errorType);
     }
 
     private static getMsg(context, param) {
-        return getMessage(context.getIf(param).orElse(UNKNOWN).value);
+        return getMessage(context.getIf(param).orElse(EMPTY_STR).value);
     }
 
     static fromServerError(context: Config): ErrorData {

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;

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

@@ -32,7 +32,6 @@ export interface IResponseProcessor {
      */
     replaceHead(shadowHead: XMLQuery | DQ): void;
 
-
     /**
      * adds new elements to the head
      *
@@ -40,6 +39,14 @@ export interface IResponseProcessor {
      */
     addToHead(newElements: XMLQuery | DQ): void;
 
+
+    /**
+     * adds new elements to the head in a deferred manner
+     *
+     * @param newElements the elements which need addition
+     */
+    addToHeadDeferred(newElements: XMLQuery | DQ): void;
+
     /**
      * replace the body
      *
@@ -142,4 +149,11 @@ export interface IResponseProcessor {
      * send last event
      */
     done(): void;
+
+    /**
+     * update internal state to
+     * check whether we still are in a named view root
+     * (can change after a navigation)
+     */
+    updateNamedViewRootState();
 }

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

@@ -14,20 +14,25 @@
  * 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,
+    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 {Assertions} from "../util/Assertions";
+
 
 /**
  * Resolver functions for various aspects of the request data
@@ -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,9 +127,15 @@ 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;
 }
 
 /**
@@ -138,14 +182,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.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;
 }