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

package/src/main/typescript/impl/PushImpl.ts

@@ -15,25 +15,21 @@
  */
 
 /**
- * Typescript port of the faces.push part in the myfaces implementation
+ * Typescript port of the faces\.push part in the myfaces implementation
  */
-
-//TODO still work in progress
-//this is a 1:1 port for the time being
 import {MAX_RECONNECT_ATTEMPTS, REASON_EXPIRED, RECONNECT_INTERVAL} from "./core/Const";
-;
-
+import {DQ} from "mona-dish";
 
 /**
  * Implementation class for the push functionality
  */
 export module PushImpl {
 
-    const URL_PROTOCOL = window.location.protocol.replace("http", "ws") + "//";
+    const URL_PROTOCOL = DQ.global().location.protocol.replace("http", "ws") + "//";
 
 
-    //we expose the member variables for testing purposes
-    //they are not directly touched outside of tests
+    // we expose the member variables for testing purposes
+    // they are not directly touched outside of tests
 
     /* socket map by token */
     export let sockets = {};
@@ -43,7 +39,7 @@ export module PushImpl {
     export let clientIdsByTokens = {};
 
 
-    //needed for testing
+    // needed for testing
     export function reset() {
         sockets = {};
         components = {}
@@ -55,58 +51,64 @@ export module PushImpl {
      */
 
     /**
-     *
-     * @param {function} onopen The function to be invoked when the web socket is opened.
-     * @param {function} onmessage The function to be invoked when a message is received.
-     * @param {function} onclose The function to be invoked when the web socket is closed.
-     * @param {boolean} autoconnect Whether or not to immediately open the socket. Defaults to <code>false</code>.
+     * @param socketClientId the sockets client identifier
+     * @param url the uri to reach the socket
+     * @param channel the channel name/id
+     * @param onopen The function to be invoked when the web socket is opened.
+     * @param onmessage The function to be invoked when a message is received.
+     * @param onerror The function to be invoked when an error occurs.
+     * @param onclose The function to be invoked when the web socket is closed.
+     * @param behaviors functions which are invoked whenever a message is received
+     * @param autoConnect Whether or not to automatically open the socket. Defaults to <code>false</code>.
      */
     export function init(socketClientId: string,
-                         uri: string,
+                         url: string,
                          channel: string,
                          onopen: Function,
                          onmessage: Function,
+                         onerror: Function,
                          onclose: Function,
-                         behaviorScripts: any,
-                         autoconnect: boolean) {
+                         behaviors: any,
+                         autoConnect: boolean) {
         onclose = resolveFunction(onclose);
 
-        if (!window.WebSocket) { // IE6-9.
+        if (!DQ.global().WebSocket) { // IE6-9.
             onclose(-1, channel);
             return;
         }
 
-        let channelToken = uri.substr(uri.indexOf('?') + 1);
+        let channelToken = url.substr(url.indexOf('?') + 1);
 
         if (!components[socketClientId]) {
             components[socketClientId] = {
                 'channelToken': channelToken,
                 'onopen': resolveFunction(onopen),
                 'onmessage' : resolveFunction(onmessage),
+                'onerror' : resolveFunction(onerror),
                 'onclose': onclose,
-                'behaviors': behaviorScripts,
-                'autoconnect': autoconnect};
+                'behaviors': behaviors,
+                'autoconnect': autoConnect};
             if (!clientIdsByTokens[channelToken]) {
                 clientIdsByTokens[channelToken] = [];
             }
             clientIdsByTokens[channelToken].push(socketClientId);
             if (!sockets[channelToken]){
                 sockets[channelToken] = new Socket(channelToken,
-                    getBaseURL(uri), channel);
+                    getBaseURL(url), channel);
             }
         }
 
-        if (autoconnect) {
-            (window?.faces ?? window?.jsf).push.open(socketClientId);
+        if (autoConnect) {
+            (DQ.global()?.faces ?? DQ.global()?.jsf).push.open(socketClientId);
         }
     }
 
     export function open(socketClientId: string) {
-        getSocket(components?.[socketClientId]?.channelToken).open();
+        getSocket(components[socketClientId]?.channelToken).open();
     }
 
     export function close(socketClientId: string) {
-        getSocket(components?.[socketClientId].channelToken).close();
+        getSocket(components[socketClientId].channelToken).close();
     }
 
     // Private helper classes
@@ -138,29 +140,51 @@ export module PushImpl {
             this.bindCallbacks();
         }
 
+        // noinspection JSUnusedLocalSymbols
         onopen(event: any) {
             if (!this.reconnectAttempts) {
                 let clientIds = clientIdsByTokens[this.channelToken];
                 for (let i = clientIds.length - 1; i >= 0; i--) {
                     let socketClientId = clientIds[i];
-                    components[socketClientId]['onopen'](this.channel);
+                    components[socketClientId]?.['onopen']?.(this.channel);
                 }
             }
             this.reconnectAttempts = 0;
         }
 
+        onerror(event: any) {
+            let message = JSON.parse(event.data);
+            //TODO replace this with a more readable Stream code
+            for (let i = clientIdsByTokens[this.channelToken].length - 1; i >= 0; i--) {
+                let socketClientId = clientIdsByTokens[this.channelToken][i];
+                if (document.getElementById(socketClientId)) {
+                    try {
+                        components[socketClientId]?.['onerror']?.(message, this.channel, event);
+                    } catch (e) {
+                        //Ignore
+                    }
+                } else {
+                    clientIdsByTokens[this.channelToken].splice(i, 1);
+                }
+            }
+            if (clientIdsByTokens[this.channelToken].length == 0) {
+                // tag disappeared
+                this.close();
+            }
+        }
+
         onmmessage(event: any) {
             let message = JSON.parse(event.data);
             for (let i = clientIdsByTokens[this.channelToken].length - 1; i >= 0; i--) {
                 let socketClientId = clientIdsByTokens[this.channelToken][i];
                 if (document.getElementById(socketClientId)) {
                     try {
-                        components[socketClientId]['onmessage'](message, this.channel, event);
+                        components[socketClientId]?.['onmessage']?.(message, this.channel, event);
                     } catch (e) {
                         //Ignore
                     }
-                    let behaviors = components[socketClientId]['behaviors'];
-                    let functions = behaviors[message];
+                    let behaviors = components?.[socketClientId]?.['behaviors'];
+                    let functions = behaviors?.[message];
                     if (functions && functions.length) {
                         for (let j = 0; j < functions.length; j++) {
                             try {
@@ -175,7 +199,7 @@ export module PushImpl {
                 }
             }
             if (clientIdsByTokens[this.channelToken].length == 0) {
-                //tag dissapeared
+                // tag disappeared
                 this.close();
             }
         }
@@ -189,7 +213,7 @@ export module PushImpl {
                 let clientIds = clientIdsByTokens[this.channelToken];
                 for (let i = clientIds.length - 1; i >= 0; i--) {
                     let socketClientId = clientIds[i];
-                    components[socketClientId]['onclose'](event?.code, this?.channel, event);
+                    components?.[socketClientId]?.['onclose']?.(event?.code, this?.channel, event);
                 }
             } else {
                 setTimeout(this.open, RECONNECT_INTERVAL * this.reconnectAttempts++);
@@ -211,6 +235,7 @@ export module PushImpl {
             this.socket.onopen = (event: Event) => this.onopen(event);
             this.socket.onmessage = (event: Event) => this.onmmessage(event);
             this.socket.onclose = (event: Event) => this.onclose(event);
+            this.socket.onerror = (event: Event) => this.onerror(event);
         }
     }
 
@@ -218,7 +243,7 @@ export module PushImpl {
 
     function getBaseURL(url: string) {
         if (url.indexOf("://") < 0) {
-            let base = window.location.hostname + ":" + window.location.port;
+            let base = DQ.global().location.hostname + ":" + DQ.global().location.port;
             return URL_PROTOCOL + base + url;
         } else {
             return url;
@@ -227,9 +252,9 @@ export module PushImpl {
 
     /**
      * Get socket associated with given channelToken.
-     * @param {string} channelToken The name of the web socket channelToken.
-     * @return {Socket} Socket associated with given channelToken.
-     * @throws {Error} When channelToken is unknown, you may need to initialize
+     * @param channelToken The name of the web socket channelToken.
+     * @return Socket associated with given channelToken.
+     * @throws Error, when the channelToken is unknown, you may need to initialize
      *                 it first via <code>init()</code> function.
      */
     function getSocket(channelToken: string): Socket {
@@ -243,7 +268,7 @@ export module PushImpl {
 
     function resolveFunction(fn: Function | string = () => {
     }): Function {
-        return <Function>((typeof fn !== "function") && (fn = window[fn]), fn);
+        return <Function>((typeof fn !== "function") && (fn = DQ.global()[fn]), fn);
     }
 
 }

package/src/main/typescript/impl/core/Const.ts

@@ -17,9 +17,16 @@
 /*
  * [export const] constants
  */
-export const P_PARTIAL_SOURCE = "jakarta.faces.source";
-export const PARTIAL_ID = "partialId";
+
+export const XML_ATTR_NAMED_VIEWROOT = "namedViewRoot";
+export const NAMED_VIEWROOT = "namedViewRoot";
+
+export const P_AJAX_SOURCE = "jakarta.faces.source";
+export const NAMING_CONTAINER_ID = "myfaces.NamingContainerId";
+
+export const VIEW_ID = "myfaces.viewId";
 export const P_VIEWSTATE = "jakarta.faces.ViewState";
+export const P_CLIENT_WINDOW = "jakarta.faces.ClientWindow";
 export const P_VIEWROOT = "jakarta.faces.ViewRoot";
 export const P_VIEWHEAD = "jakarta.faces.ViewHead";
 export const P_VIEWBODY = "jakarta.faces.ViewBody";
@@ -33,7 +40,8 @@ export const EMPTY_FUNC = Object.freeze(() => {
 export const EMPTY_STR = "";
 export const EMPTY_MAP = Object.freeze({});
 
-export const HTML_VIEWSTATE = ["<input type='hidden'", "id='", P_VIEWSTATE, "' name='", P_VIEWSTATE, "' value='' />"].join(EMPTY_STR);
+export const HTML_VIEWSTATE = ["<input type='hidden'", "name='", P_VIEWSTATE, "' value='' />"].join(EMPTY_STR);
+export const HTML_CLIENT_WINDOW = ["<input type='hidden'", "' name='", P_CLIENT_WINDOW, "' value='' />"].join(EMPTY_STR);
 
 
 /*internal identifiers for options*/
@@ -46,8 +54,10 @@ export const IDENT_FORM = "@form";
 export const P_AJAX = "jakarta.faces.partial.ajax";
 export const P_EXECUTE = "jakarta.faces.partial.execute";
 export const P_RENDER = "jakarta.faces.partial.render";
+/*render override for viewbody or viewroot, in both cases an all is performed*/
+export const P_RENDER_OVERRIDE = "_myfaces.rendeOverride";
 export const P_EVT = "jakarta.faces.partial.event";
-export const P_CLIENT_WINDOW = "jakarta.faces.ClientWindow";
+
 export const P_RESET_VALUES = "jakarta.faces.partial.resetValues";
 export const P_WINDOW_ID = "jakarta.faces.windowId";
 
@@ -87,19 +97,18 @@ export const SERVER_ERROR = "serverError";
 export const CLIENT_ERROR = "clientError";
 export const TIMEOUT_EVENT = "timeout";
 
-export const CTX_PARAM_MF_INTERNAL = "_mfInternal";
-
-export const CTX_PARAM_SRC_FRM_ID = "_mfSourceFormId";
-export const CTX_PARAM_SRC_CTL_ID = "_mfSourceControlId";
-export const CTX_PARAM_TR_TYPE = "_mfTransportType";
-export const CTX_PARAM_PASS_THR = "passThrgh";
-export const CTX_PARAM_DELAY = "delay";
-export const CTX_PARAM_TIMEOUT = "timeout";
-export const CTX_PARAM_RST = "resetValues";
-export const CTX_PARAM_EXECUTE = "execute";
-
-export const STAGE_DEVELOPMENT = "Development";
+export const CTX_OPTIONS_PARAMS = "params";
+export const CTX_OPTIONS_DELAY = "delay";
+export const DELAY_NONE = 'none';
+export const CTX_OPTIONS_TIMEOUT = "timeout";
+export const CTX_OPTIONS_RESET = "resetValues";
+export const CTX_OPTIONS_EXECUTE = "execute";
 
+export const CTX_PARAM_MF_INTERNAL = "myfaces.internal";
+export const CTX_PARAM_SRC_FRM_ID = "myfaces.source.formId";
+export const CTX_PARAM_SRC_CTL_ID = "myfaces.source.controlId";
+export const CTX_PARAM_REQ_PASS_THR = "myfaces.request.passThrough";
+export const CTX_PARAM_PPS = "myfaces.request.pps";
 
 export const CONTENT_TYPE = "Content-Type";
 export const HEAD_FACES_REQ = "Faces-Request";
@@ -116,13 +125,12 @@ export const MULTIPART = "multipart/form-data";
 export const NO_TIMEOUT = 0;
 export const STD_ACCEPT = "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8";
 
-export const TAG_HEAD = "head";
-export const TAG_FORM = "form";
-export const TAG_BODY = "body";
-export const TAG_BEFORE = "before";
-export const TAG_AFTER = "after";
-
-export const TAG_ATTR = "attribute";
+export const HTML_TAG_HEAD = "HEAD";
+export const HTML_TAG_FORM = "FORM";
+export const HTML_TAG_BODY = "BODY";
+export const HTML_TAG_LINK = "LINK";
+export const HTML_TAG_SCRIPT = "SCRIPT";
+export const HTML_TAG_STYLE = "STYLE";
 
 
 export const SEL_VIEWSTATE_ELEM = "[name='" + P_VIEWSTATE + "']";
@@ -134,44 +142,48 @@ export const PHASE_PROCESS_RESPONSE = "processResponse";
 
 export const ERR_NO_PARTIAL_RESPONSE = "Partial response not set";
 
+export const MYFACES_OPTION_PPS = "pps";
+
 export const ATTR_URL = "url";
 export const ATTR_NAME = "name";
 export const ATTR_VALUE = "value";
 export const ATTR_ID = "id";
 
 /*partial response types*/
-export const RESP_PARTIAL = "partial-response";
+export const XML_TAG_PARTIAL_RESP = "partial-response";
 
 /*partial commands*/
-export const CMD_CHANGES = "changes";
-export const CMD_UPDATE = "update";
-export const CMD_DELETE = "delete";
-export const CMD_INSERT = "insert";
-export const CMD_EVAL = "eval";
-export const CMD_ERROR = "error";
-export const CMD_ATTRIBUTES = "attributes";
-export const CMD_EXTENSION = "extension";
-export const CMD_REDIRECT = "redirect";
+export const XML_TAG_CHANGES = "changes";
+export const XML_TAG_UPDATE = "update";
+export const XML_TAG_DELETE = "delete";
+export const XML_TAG_INSERT = "insert";
+export const XML_TAG_EVAL = "eval";
+export const XML_TAG_ERROR = "error";
+export const XML_TAG_ATTRIBUTES = "attributes";
+export const XML_TAG_EXTENSION = "extension";
+export const XML_TAG_REDIRECT = "redirect";
+export const XML_TAG_BEFORE = "before";
+export const XML_TAG_AFTER = "after";
+export const XML_TAG_ATTR = "attribute";
+
 
 /*other constants*/
 
-export const UPDATE_FORMS = "_updateForms";
-export const UPDATE_ELEMS = "_updateElems";
+export const UPDATE_FORMS = "myfaces.updateForms";
+export const UPDATE_ELEMS = "myfaces.updateElems";
 
 //we want the head elements to be processed before we process the body
 //but after the inner html is done
-export const DEFERRED_HEAD_INSERTS = "_headElems";
+export const DEFERRED_HEAD_INSERTS = "myfaces.headElems";
 
 export const MYFACES = "myfaces";
 
-export const SEL_SCRIPTS_STYLES = "script, style, link";
-
 export const MF_NONE = "__mf_none__";
 
 export const REASON_EXPIRED = "Expired";
 
-export const APPLIED_VST = "appliedViewState";
-export const APPLIED_CLIENT_WINDOW = "appliedClientWindow";
+export const APPLIED_VST = "myfaces.appliedViewState";
+export const APPLIED_CLIENT_WINDOW = "myfaces.appliedClientWindow";
 
 export const RECONNECT_INTERVAL = 500;
 export const MAX_RECONNECT_ATTEMPTS = 25;
@@ -186,6 +198,10 @@ export const UNKNOWN = "UNKNOWN";
  * changed to a simple value passthrough
  */
 
+export function $faces(): FacesAPI {
+     return (window?.faces ?? window?.jsf) as FacesAPI;
+}
+
 export function $nsp(inputNamespace?: any): any {
      if((!inputNamespace) || !inputNamespace?.replace) {
           return inputNamespace;

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, "_Ajaxthis.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/AsyncRunnable.ts

@@ -18,7 +18,7 @@
  * Asynchronous queue member for our asynchronous queue
  * Ever object in the asynchronous queue needs to implement this interface
  *
- * the usage should be similar as a Promise from the outside.
+ * the usage should be similar as Promise. from the outside.
  * but with a dedicated start point. The problem why we cannot use
  * promises here, is mostly related to the needed cancel functionality
  * and that the queue expects a runnable as entry.
@@ -26,7 +26,7 @@
  * from the implementation side it is mostly registering callbacks
  * and calling them at the appropriate time.
  */
-export interface AsyncRunnable<T> {
+export interface IAsyncRunnable<T> {
     /**
      * starts the runnable
      */
@@ -42,24 +42,24 @@ export interface AsyncRunnable<T> {
      * triggered when the async run is complete
      *
      * the async runnable must register the passed function
-     * and then triggers all the registered thens
+     * and then triggers all the registered then functions
      * when it is complete
      *
-     * @param func
+     * @param func the then functor
      */
-    then(func: (data: any) => any): AsyncRunnable<T>;
+    then(func: (data: any) => any): IAsyncRunnable<T>;
 
     /**
      * callback for catch functionality
-     * triggered when the asynch run is complete
+     * triggered when the async run is complete
      *
      * the async runnable must register the passed function
-     * and then triggers all the registered catchs
+     * and then triggers all the registered catch handlers
      * when an error has occurred
      *
      * @param func
      */
-    catch(func: (data: any) => any): AsyncRunnable<T>;
+    catch(func: (data: any) => any): IAsyncRunnable<T>;
 
 
     /**
@@ -68,5 +68,80 @@ export interface AsyncRunnable<T> {
      * and once the finally time for the promise has
      * come the finally functions must be performed
      */
-    finally(func: () => void): AsyncRunnable<T>;
-}
+    finally(func: () => void): IAsyncRunnable<T>;
+}
+
+
+/**
+ * pretty much the same as cancellable Promise, but given
+ * we do not have that on browser level yet this is sort
+ * of a non - intrusive Shim!
+ */
+export abstract class AsyncRunnable<T> implements IAsyncRunnable<T>{
+    /**
+     * helper support so that we do not have to drag in Promise shims
+     */
+    private catchFunctions: Array<Function> = [];
+    private thenFunctions: Array<Function> = [];
+
+    /**
+     * cancel the run of the runnable (which then depending on the implementation
+     * either triggers indirectly resolve or reject)
+     */
+    abstract cancel(): void;
+
+    /**
+     * extended functionality start to trigger the runnable
+     */
+    abstract start(): void;
+
+    /**
+     * resolve handler function which calls the then chain
+     * and after that finally
+     * @param data
+     */
+    resolve(data: any) {
+        this.thenFunctions.reduce((inputVal: any, thenFunc: any) => {
+            return thenFunc(inputVal);
+        }, data)
+    }
+
+    /**
+     * reject handler function which triggers the catch chain
+     * @param data
+     */
+    reject(data: any) {
+        this.catchFunctions.reduce((inputVal: any, catchFunc: any) => {
+            return catchFunc(inputVal);
+        }, data);
+    }
+
+    /**
+     * register a catch functor
+     * @param func the functor for the catch monad
+     */
+    catch(func: (data: any) => any): IAsyncRunnable<T> {
+        this.catchFunctions.push(func);
+        return this;
+    }
+
+    /**
+     * registers a finally functor
+     * @param func the functor for the finally handling chanin
+     */
+    finally(func: () => void): IAsyncRunnable<T> {
+        // no ie11 support we probably are going to revert to shims for that one
+        this.catchFunctions.push(func);
+        this.thenFunctions.push(func);
+        return this;
+    }
+
+    /**
+     * @param func then functor similar to promise
+     */
+    then(func: (data: any) => any): IAsyncRunnable<T> {
+        this.thenFunctions.push(func);
+        return this;
+    }
+}
+