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

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 {Lang as LangBase, Config, Optional, DomQuery, DQ} 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";
 
 
@@ -38,11 +36,11 @@ export module ExtLang {
 
     //should be in lang, but for now here to avoid recursive imports, not sure if typescript still has a problem with those
     /**
-     * helper function to savely resolve anything
+     * helper function to safely resolve anything
      * this is not an elvis operator, it resolves
      * a value without exception in a tree and if
      * it is not resolvable then an optional of
-     * a default value is restored or Optional.empty
+     * a default value is restored or Optional\.empty
      * if none is given
      *
      * usage
@@ -51,7 +49,7 @@ export module ExtLang {
      * </code>
      *
      * @param resolverProducer a lambda which can produce the value
-     * @param defaultValue an optional default value if the producer failes to produce anything
+     * @param defaultValue an optional default value if the producer fails to produce anything
      * @returns an Optional of the produced value
      */
     export function failSaveResolve<T>(resolverProducer: () => T, defaultValue: T = null): Optional<T> {
@@ -75,10 +73,10 @@ export module ExtLang {
      * returns a given localized message upon a given key
      * basic java log like templating functionality is included
      *
-     * @param {String} key the key for the message
-     * @param {String} defaultMessage optional default message if none was found
+     * @param  key the key for the message
+     * @param  defaultMessage optional default message if none was found
      *
-     * Additionally you can pass additional arguments, which are used
+     * Additionally, you can pass additional arguments, which are used
      * in the same way java log templates use the params
      *
      * @param templateParams the param list to be filled in
@@ -87,10 +85,10 @@ export module ExtLang {
         installedLocale = installedLocale ?? new Messages();
 
         let msg = installedLocale[key] ?? defaultMessage ?? key;
-
-        Stream.of(...templateParams).each((param, cnt) => {
+        templateParams.forEach((param, cnt) => {
             msg = msg.replace(new RegExp(["\\{", cnt, "\\}"].join(EMPTY_STR), "g"), param);
-        });
+        })
+
 
         return msg;
     }
@@ -106,15 +104,15 @@ export module ExtLang {
     }
 
     /**
-     * creates an exeption with additional internal parameters
+     * creates an exception with additional internal parameters
      * for extra information
      *
      * @param error
-     * @param {String} title the exception title
-     * @param {String} name  the exception name
-     * @param {String} callerCls the caller class
-     * @param {String} callFunc the caller function
-     * @param {String} message the message for the exception
+     * @param  title the exception title
+     * @param  name  the exception name
+     * @param  callerCls the caller class
+     * @param  callFunc the caller function
+     * @param  message the message for the exception
      */
     export function makeException(error: Error, title: string, name: string, callerCls: string, callFunc: string, message: string): Error {
 
@@ -124,14 +122,14 @@ export module ExtLang {
 
     /**
      * fetches a global config entry
-     * @param {String} configName the name of the configuration entry
-     * @param {Object} defaultValue
+     * @param  configName the name of the configuration entry
+     * @param  defaultValue
      *
      * @return either the config entry or if none is given the default value
      */
     export function getGlobalConfig(configName: string, defaultValue: any): any {
         /**
-         * note we could use exists but this is an heavy operation, since the config name usually
+         * note we could use exists but this is a heavy operation, since the config name usually
          * given this function here is called very often
          * is a single entry without . in between we can do the lighter shortcut
          */
@@ -139,7 +137,7 @@ export module ExtLang {
     }
 
     /**
-     * fetches the form in an fuzzy manner depending
+     * fetches the form in a fuzzy manner depending
      * on an element or event target.
      *
      * The idea is that according to the jsf spec
@@ -148,7 +146,7 @@ export module ExtLang {
      * This is fine, but since then html5 came into the picture with the form attribute the element
      * can be anywhere referencing its parent form.
      *
-     * Also theoretically you can have the case of an issuing element enclosing a set of forms
+     * Also, theoretically you can have the case of an issuing element enclosing a set of forms
      * (not really often used, but theoretically it could be input button allows to embed html for instance)
      *
      * So the idea is not to limit the issuing form determination to the spec case
@@ -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);
@@ -190,10 +188,11 @@ export module ExtLang {
      * gets the local or global options with local ones having higher priority
      * if no local or global one was found then the default value is given back
      *
-     * @param {String} configName the name of the configuration entry
-     * @param {String} localOptions the local options root for the configuration myfaces as default marker is added implicitely
+     * @param  configName the name of the configuration entry
+     * @param  localOptions the local options root for the configuration myfaces as default marker is added
+     * implicitly
      *
-     * @param {Object} defaultValue
+     * @param  defaultValue
      *
      * @return either the config entry or if none is given the default value
      */
@@ -203,6 +202,61 @@ export module ExtLang {
             defaultValue;
     }
 
+    /**
+     * expands an associative array into an array of key value tuples
+     * @param value
+     */
+    export function ofAssoc(value: {[key: string]: any}) {
+        return Object.keys(value)
+            .map(key => [key, value[key]]);
+    }
+
+    export function collectAssoc(target: any, item: any) {
+        target[item[0]] = item[1];
+        return target;
+    }
+
+    /**
+     * The active timeout for the "debounce".
+     * Since we only use it in the XhrController
+     * we can use a local module variable here
+     */
+    let activeTimeouts = {};
+
+
+
+
+    /**
+     * a simple debounce function
+     * which waits until a timeout is reached and
+     * if something comes in in between debounces
+     *
+     * @param runnable a runnable which should go under debounce control
+     * @param timeout a timeout for the debounce window
+     */
+    export function debounce(key, runnable, timeout) {
+        function clearActiveTimeout() {
+            clearTimeout(activeTimeouts[key]);
+            delete activeTimeouts[key];
+        }
+
+        if (!!(activeTimeouts?.[key])) {
+            clearActiveTimeout();
+        }
+        if (timeout > 0) {
+            activeTimeouts[key] = setTimeout(() => {
+                try {
+                    runnable();
+                } finally {
+                    clearActiveTimeout();
+                }
+            }, timeout);
+        } else {
+            runnable();
+        }
+    }
+
+
     /**
      * assert that the form exists and throw an exception in the case it does not
      *
@@ -213,4 +267,6 @@ export module ExtLang {
             throw makeException(new Error(), null, null, "Impl", "getForm", getMessage("ERR_FORM"));
         }
     }
+
+
 }

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

@@ -0,0 +1,112 @@
+import {IAsyncRunnable} from "./AsyncRunnable";
+import {ExtLang} from "./Lang";
+import debounce = ExtLang.debounce;
+
+/**
+ * A simple XHR queue controller
+ * following the async op -> next pattern
+ * Faces enforces for the XHR handling
+ */
+export class XhrQueueController<T extends IAsyncRunnable<any>> {
+    queue = [];
+    taskRunning = false;
+
+    constructor() {
+    }
+
+    /**
+     * executes or enqueues an element
+     * @param runnable the runnable (request) to be enqueued
+     * @param timeOut timeout if > 0 which defers the execution
+     * until the debounce window for the timeout is closed.
+     */
+    enqueue(runnable: T, timeOut: number = 0) {
+        debounce("xhrQueue", () => {
+            const requestHandler = this.enrichRunnable(runnable);
+            if (!this.taskRunning) {
+                this.signalTaskRunning();
+                requestHandler.start();
+            } else {
+                this.queue.push(requestHandler);
+            }
+        }, timeOut);
+    }
+
+    /**
+     * trigger the next element in the queue
+     * to be started!
+     */
+    next() {
+        this.updateTaskRunning();
+        const next = this.queue.shift();
+        next?.start();
+    }
+
+    /**
+     * clears and resets the queue
+     */
+    clear() {
+        this.queue.length = 0;
+        this.updateTaskRunning();
+    }
+
+    /**
+     * true if queue is empty
+     */
+    get isEmpty(): boolean {
+        return !this.queue.length;
+    }
+
+    /**
+     * Enriches the incoming async asyncRunnable
+     * with the error and next handling
+     * (aka: asyncRunnable is done -> next
+     *                   error -> clear queue
+     * @param asyncRunnable the async runnable which needs enrichment
+     * @private
+     */
+    private enrichRunnable(asyncRunnable: T) {
+        /**
+         * we can use the Promise pattern asyncrunnable uses
+         * to trigger queue control callbacks of next element
+         * and clear the queue (theoretically this
+         * would work with any promise)
+         */
+        try {
+            return asyncRunnable
+                .then(() => this.next())
+                .catch((e) => this.handleError(e));
+        } catch (e) {
+            this.handleError(e);
+        }
+    }
+
+
+    /**
+     * alerts the queue that a task is running
+     *
+     * @private
+     */
+    private signalTaskRunning() {
+        this.taskRunning = true;
+    }
+
+    /**
+     * updates the task running status according to the current queue
+     * @private
+     */
+    private updateTaskRunning() {
+        this.taskRunning = !this.isEmpty;
+    }
+
+    /**
+     * standard error handling
+     * we clear the queue and then bomb out
+     * @param e
+     * @private
+     */
+    private handleError(e) {
+        this.clear();
+        throw e;
+    }
+}

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_AJAX_SOURCE, SOURCE} from "../core/Const";
 
 export class EventData implements IEventData{
     type: string;
@@ -32,8 +32,8 @@ export class EventData implements IEventData{
         eventData.status = name;
 
         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(P_AJAX_SOURCE).value)
+            .orElseLazy(() => context.getIf(CTX_PARAM_REQ_PASS_THR, P_AJAX_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
      *
@@ -48,7 +55,7 @@ export interface IResponseProcessor {
     replaceBody(shadowBody: XMLQuery | DQ): void;
 
     /**
-     * Leaf Tag eval... process whatever is in the evals cdata block
+     * Leaf Tag eval... process whatever is in the evaluated cdata block
      *
      * @param node
      */
@@ -91,11 +98,11 @@ export interface IResponseProcessor {
     attributes(node: XMLQuery): void;
 
     /**
-     * replace the entire viewroot
+     * replace the entire viewRoot
      * with shadowResponse
-     * @param shadownResponse
+     * @param shadowResponse
      */
-    replaceViewRoot(shadownResponse: XMLQuery | DQ): void;
+    replaceViewRoot(shadowResponse: XMLQuery | DQ): void;
 
     /**
      * jsf insert resolution
@@ -106,34 +113,34 @@ export interface IResponseProcessor {
     insert(node: XMLQuery): void;
 
     /**
-     * insert with before, after subtags
+     * insert with before, after sub-tags
      * @param node
      */
-    insertWithSubtags(node: XMLQuery);
+    insertWithSubTags(node: XMLQuery);
 
     /**
      * process the viewState update, update the affected
-     * forms with their respective new viewstate values
+     * forms with their respective new viewState values
      *
      */
     processViewState(node: XMLQuery): boolean;
 
     /**
      * process the viewState update, update the affected
-     * forms with their respective new viewstate values
+     * forms with their respective new viewState values
      *
      */
     processClientWindow(node: XMLQuery): boolean;
 
 
     /**
-     * evals all processed elements of so far
+     * Eval - all processed elements so far
      * and executes the embedded scripts
      */
     globalEval(): void;
 
     /**
-     * fix the viewstates of all processed forms
+     * fix the viewStates of all processed forms
      */
     fixViewStates(): void;
 
@@ -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();
 }