jsf.js_next_gen 1.0.0-beta-20 → 4.0.0-RC.1

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

@@ -1,4 +1,4 @@
-/* Licensed to the Apache Software Foundation (ASF) under one or more
+/*! 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
@@ -13,36 +13,44 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import {Config, IValueHolder, Optional, DomQuery, DQ} from "mona-dish";
-import {P_WINDOW_ID} from "../core/Const";
-
-declare let window: any;
+import {Config, IValueHolder, Optional, DomQuery, DQ, Stream, ArrayCollector} from "mona-dish";
+import {$nsp, P_WINDOW_ID} from "../core/Const";
 
 
 /**
- * detects whether a source is a jsf.js request
+ * detects whether a source is a faces.js request
  *
- * @param source the source string for the jsf.js request
- * @return true if a jsf.js loading pattern is detected
+ * @param source the source string for the faces.js request
+ * @return true if a faces.js loading pattern is detected
  * @constructor
  */
-const IS_JSF_SOURCE = (source?: string): boolean => {
-    return source && !!(source?.search(/\/javax\.faces\.resource.*\/jsf\.js.*/) != -1 ||
-        source?.search(/\/jsf-development\.js.*/) != -1 ||
-        source?.search(/\/jsf-uncompressed\.js.*/) != -1 ||
-        source?.search(/\/jsf[^.]*\.js.*ln=javax.faces.*/gi) != -1);
+const IS_FACES_SOURCE = (source?: string): boolean => {
+    //spec version smaller 4 we have to deal with the jsf namespace
+
+    return source && !!(source?.search(/\/jakarta\.faces\.resource.*\/faces\.js.*/) != -1 ||
+        source?.search(/\/faces-development\.js.*/) != -1 ||
+        source?.search(/\/faces-uncompressed\.js.*/) != -1 ||
+        source?.search(/\/faces[^.]*\.js.*ln=jakarta.faces.*/gi) != -1 ||
+        //fallback without check for jsf, that way we allow both bookmarks
+        source?.search(/\/javax\.faces\.resource.*\/jsf\.js.*/) != -1 ||
+            source?.search(/\/jsf-development\.js.*/) != -1 ||
+            source?.search(/\/jsf-uncompressed\.js.*/) != -1 ||
+            source?.search(/\/jsf[^.]*\.js.*ln=javax.faces.*/gi) != -1);
 }
 
 /**
- * namespace myfaces.testscripts can be used as extension point for internal
- * tests, those will be handled similarly to jsf.js regarding
- * reload blocking on ajax requests
+ * namespace myfaces\.testscripts can be used as extension point for internal
+ * tests, those will be handled similarly to faces.js, in regard
+ * to reload blocking on ajax requests
+ *
+ * Note: atm not used, used to be used in the old implementation
+ * but still is reserved for now
  *
  * @param source the source to check
  * @constructor
  */
 const IS_INTERNAL_SOURCE = (source: string): boolean => {
-    return  source.search(/\/jsf[^.]*\.js.*ln=myfaces.testscripts.*/gi) != -1;
+    return source.search(/\/faces[^.]*\.js.*ln=myfaces.testscripts.*/gi) != -1 || source.search(/\/jsf[^.]*\.js.*ln=myfaces.testscripts.*/gi) != -1;
 }
 
 
@@ -50,21 +58,21 @@ const ATTR_SRC = 'src';
 
 /**
  * Extension which adds implementation specific
- * meta data to our dom query
+ * meta-data to our dom query
  *
  * Usage
  * el = new ExtDQ(oldReference)
  * nonce = el.nonce
  * windowId = el.getWindowId
  */
-export class ExtDomquery extends DQ {
+export class ExtDomQuery extends DQ {
 
     static get windowId() {
-        return new ExtDomquery(document.body).windowId;
+        return new ExtDomQuery(document.body).windowId;
     }
 
     static get nonce(): string {
-        return new ExtDomquery(document.body).nonce;
+        return new ExtDomQuery(document.body).nonce;
     }
 
     get windowId(): string | null {
@@ -82,7 +90,7 @@ export class ExtDomquery extends DQ {
         //byId ($)
         if (this.value.isPresent()) {
             let result = this.querySelectorAll("form input[name='" + P_WINDOW_ID + "']");
-            if (result.length > 0) {
+            if (result.length > 1) {
                 throw Error("Multiple different windowIds found in document");
             }
 
@@ -93,12 +101,12 @@ export class ExtDomquery extends DQ {
     }
 
     /*
-    * determines the jsf.js nonce and adds them to the namespace
+    * determines the faces.js nonce and adds them to the namespace
     * this is done once and only lazily
     */
     get nonce(): string | null {
         //already processed
-        let myfacesConfig = new Config(window.myfaces);
+        let myfacesConfig = new ExtConfig(window.myfaces);
         let nonce: IValueHolder<string> = myfacesConfig.getIf("config", "cspMeta", "nonce");
         if (nonce.value) {
             return <string>nonce.value;
@@ -106,61 +114,120 @@ export class ExtDomquery extends DQ {
 
         let curScript = new DQ(document.currentScript);
         //since our baseline atm is ie11 we cannot use document.currentScript globally
-        if (curScript.attr("nonce").value != null) {
-            // fastpath for modern browsers
-            return curScript.attr("nonce").value;
+        if (!!this.extractNonce(curScript)) {
+            // fast-path for modern browsers
+            return this.extractNonce(curScript);
         }
         // fallback if the currentScript method fails, we just search the jsf tags for nonce, this is
         // the last possibility
         let nonceScript = DQ
             .querySelectorAll("script[src], link[src]")
             .lazyStream
-            .filter((item) => item.attr("nonce").value != null && item.attr(ATTR_SRC) != null)
-            .map(item => IS_JSF_SOURCE(item.attr(ATTR_SRC).value))
+            .filter((item) => this.extractNonce(item)  && item.attr(ATTR_SRC) != null)
+            .filter(item => IS_FACES_SOURCE(item.attr(ATTR_SRC).value))
             .first();
 
         if (nonceScript.isPresent()) {
-            nonce.value = DomQuery.byId(nonceScript.value, true).attr("nonce").value;
+            return this.extractNonce(nonceScript.value);
         }
-        return <string>nonce.value;
+        return null;
     }
 
     static searchJsfJsFor(item: RegExp): Optional<String> {
-        return new ExtDomquery(document).searchJsfJsFor(item);
+        return new ExtDomQuery(document).searchJsfJsFor(item);
     }
 
     /**
-     * searches the embedded jsf.js for items like separator char etc..
+     * searches the embedded faces.js for items like separator char etc.
      * expects a match as variable under position 1 in the result match
-     * @param rexp
+     * @param regExp
      */
-    searchJsfJsFor(rexp: RegExp): Optional<string> {
+    searchJsfJsFor(regExp: RegExp): Optional<string> {
         //perfect application for lazy stream
         return DQ.querySelectorAll("script[src], link[src]").lazyStream
-                .filter(item => IS_JSF_SOURCE(item.attr(ATTR_SRC).value))
-                .map(item => item.attr(ATTR_SRC).value.match(rexp))
-                .filter(item => item != null && item.length > 1)
-                .map((result: string[]) => {
-                    return decodeURIComponent(result[1]);
-                }).first();
+            .filter(item => IS_FACES_SOURCE(item.attr(ATTR_SRC).value))
+            .map(item => item.attr(ATTR_SRC).value.match(regExp))
+            .filter(item => item != null && item.length > 1)
+            .map((result: string[]) => {
+                return decodeURIComponent(result[1]);
+            }).first();
     }
 
     globalEval(code: string, nonce ?: string): DQ {
-        return new ExtDomquery(super.globalEval(code, nonce ?? this.nonce));
+        return new ExtDomQuery(super.globalEval(code, nonce ?? this.nonce));
+    }
+
+    // called from base class runScripts, do not delete
+    // noinspection JSUnusedGlobalSymbols
+    globalEvalSticky(code: string, nonce ?: string): DQ {
+        return new ExtDomQuery(super.globalEvalSticky(code, nonce ?? this.nonce));
     }
 
     /**
      * decorated run scripts which takes our jsf extensions into consideration
      * (standard DomQuery will let you pass anything)
-     * @param whilteListed
+     * @param sticky if set to true the internally generated element for the script is left in the dom
+     * @param whiteListed
      */
-    runScripts(whilteListed?: (src: string) => boolean): DomQuery {
+    runScripts(sticky = false, whiteListed?: (src: string) => boolean): DomQuery {
         const whitelistFunc = (src: string): boolean => {
-            return (whilteListed?.(src) ?? true) && !IS_JSF_SOURCE(src)  && !IS_INTERNAL_SOURCE(src);
+            return (whiteListed?.(src) ?? true) && !IS_FACES_SOURCE(src) && !IS_INTERNAL_SOURCE(src);
         };
-        return super.runScripts(whitelistFunc);
+        return super.runScripts(sticky, whitelistFunc);
     }
 
+    /**
+     * adds the elements in this ExtDomQuery to the head
+     *
+     * @param suppressDoubleIncludes checks for existing elements in the head before running the insert
+     */
+    runHeadInserts(suppressDoubleIncludes = true): void {
+        let head = ExtDomQuery.byId(document.head);
+        //automated nonce handling
+        let processedScripts = [];
+
+        // the idea is only to run head inserts on resources
+        // which do not exist already, that way
+        // we can avoid double includes on subsequent resource
+        // requests.
+        function resourceIsNew(element: DomQuery) {
+            if(!suppressDoubleIncludes) {
+                return true;
+            }
+            const tagName = element.tagName.value;
+            if(!tagName) {
+                // text node they do not have tag names, so we can process them as they are without
+                // any further ado
+                return true;
+            }
+            let reference = element.attr("href")
+                .orElse(element.attr("src").value)
+                .orElse(element.attr("rel").value);
+
+            if (!reference.isPresent()) {
+                return true;
+            }
+            return !head.querySelectorAll(`${tagName}[href='${reference.value}']`).length &&
+                !head.querySelectorAll(`${tagName}[src='${reference.value}']`).length &&
+                !head.querySelectorAll(`${tagName}[rel='${reference.value}']`).length;
+        }
+
+        this
+            .filter(resourceIsNew)
+            .each(element => {
+                if(element.tagName.value != "SCRIPT") {
+                    //we need to run runScripts properly to deal with the rest
+                    new ExtDomQuery(...processedScripts).runScripts(true);
+                    processedScripts = [];
+                    head.append(element);
+                } else {
+                    processedScripts.push(element);
+                }
+            });
+        new ExtDomQuery(...processedScripts).runScripts(true);
+    }
+
+
     /**
      * byId producer
      *
@@ -170,8 +237,93 @@ export class ExtDomquery extends DQ {
      */
     static byId(selector: string | DomQuery | Element, deep = false): DomQuery {
         const ret = DomQuery.byId(selector, deep);
-        return new ExtDomquery(ret);
+        return new ExtDomQuery(ret);
     }
+
+    private extractNonce(curScript: DomQuery) {
+        return (curScript.getAsElem(0).value as HTMLElement)?.nonce ?? curScript.attr("nonce").value;
+    }
+
 }
 
-export const ExtDQ = DQ;
+export const ExtDQ = ExtDomQuery;
+
+/**
+ * in order to reduce the number of interception points for the fallbacks we add
+ * the namespace remapping straight to our config accessors
+ */
+export class ExtConfig extends  Config {
+
+    constructor(root: any) {
+        super(root);
+    }
+
+    assignIf(condition: boolean, ...accessPath): IValueHolder<any> {
+        const accessPathMapped = this.remap(accessPath);
+        return super.assignIf(condition, ...accessPathMapped);
+    }
+
+    assign(...accessPath): IValueHolder<any> {
+        const accessPathMapped = this.remap(accessPath);
+        return super.assign(...accessPathMapped);
+    }
+
+    append(...accessPath): IValueHolder<any> {
+        return super.append(...accessPath);
+    }
+
+    appendIf(condition: boolean, ...accessPath): IValueHolder<any> {
+        const accessPathMapped = this.remap(accessPath);
+        return super.appendIf(condition, ...accessPathMapped);
+    }
+
+    getIf(...accessPath): Config {
+        const accessPathMapped = this.remap(accessPath);
+        return super.getIf(...accessPathMapped);
+    }
+
+    get(defaultVal: any): Config {
+        return super.get($nsp(defaultVal));
+    }
+
+    delete(key: string): Config {
+        return super.delete($nsp(key));
+    }
+
+    /**
+     * creates a config from an initial value or null
+     * @param value
+     */
+    static fromNullable<T>(value?: T | null): Config {
+        return new ExtConfig(value);
+    }
+
+    protected getClass(): any {
+        return ExtConfig;
+    }
+
+    /**
+     * shallow copy getter, copies only the first level, references the deeper nodes
+     * in a shared manner
+     */
+    protected shallowCopy$(): Config {
+        const ret = super.shallowCopy$();
+        return new ExtConfig(ret);
+    }
+
+    /**
+     * deep copy, copies all config nodes
+     */
+    get deepCopy(): Config {
+        return new ExtConfig(super.deepCopy$());
+    }
+
+    /**
+     * helper to remap the namespaces of an array of access paths
+     * @param accessPath the access paths to be remapped
+     * @private returns an array of access paths with version remapped namespaces
+     */
+    private remap(accessPath: any[]) {
+        return Stream.of(...accessPath).map(key => $nsp(key)).collect(new ArrayCollector());
+    }
+}

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

@@ -1,4 +1,4 @@
-/* Licensed to the Apache Software Foundation (ASF) under one or more
+/*! 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

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

@@ -1,4 +1,4 @@
-/* Licensed to the Apache Software Foundation (ASF) under one or more
+/*! 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
@@ -22,6 +22,7 @@ import {Messages} from "../i18n/Messages";
 import {EMPTY_STR, TAG_FORM} from "../core/Const";
 import {getEventTarget} from "../xhrCore/RequestDataResolver";
 
+
 export module ExtLang {
 
     let installedLocale: Messages;
@@ -37,11 +38,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
@@ -50,7 +51,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> {
@@ -74,10 +75,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
@@ -105,15 +106,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 {
 
@@ -123,22 +124,22 @@ 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
          */
-        return (<any>window)?.myfaces?.config?.[configName] ?? defaultValue;
+        return window?.myfaces?.config?.[configName] ?? defaultValue;
     }
 
     /**
-     * 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
@@ -147,7 +148,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
@@ -189,22 +190,22 @@ 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
      */
     export function getLocalOrGlobalConfig(localOptions: Config, configName: string, defaultValue: any): any {
         return localOptions.value?.myfaces?.config?.[configName] ??
-            (<any>window)?.myfaces?.config?.[configName] ??
+            window?.myfaces?.config?.[configName] ??
             defaultValue;
     }
 
     /**
      * assert that the form exists and throw an exception in the case it does not
-     * (TODO move this into the assertions)
      *
      * @param form the form to check for
      */
@@ -213,5 +214,4 @@ export module ExtLang {
             throw makeException(new Error(), null, null, "Impl", "getForm", getMessage("ERR_FORM"));
         }
     }
-
 }

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

@@ -1,4 +1,4 @@
-/* Licensed to the Apache Software Foundation (ASF) under one or more
+/*! 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
@@ -46,7 +46,7 @@ export enum ErrorType {
  * everything into the same attributes,
  * I will add deprecated myfaces backwards compatibility attributes as well
  */
-export class ErrorData extends EventData {
+export class ErrorData extends EventData implements IErrorData {
 
     type: string = "error";
     source: string;
@@ -59,7 +59,6 @@ export class ErrorData extends EventData {
     status: string;
     typeDetails: ErrorType;
 
-    //TODO backwards compatible attributes
     serverErrorName: string;
     serverErrorMessage: string;
     message: string;

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

@@ -1,4 +1,4 @@
-/* Licensed to the Apache Software Foundation (ASF) under one or more
+/*! 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
@@ -16,7 +16,7 @@
 import {Config, DQ} from "mona-dish";
 import {BEGIN, CTX_PARAM_PASS_THR, EVENT, P_PARTIAL_SOURCE, SOURCE} from "../core/Const";
 
-export class EventData {
+export class EventData implements IEventData{
     type: string;
     status: string;
     source: any;
@@ -33,7 +33,8 @@ export class EventData {
 
         let sourceId: string = context.getIf(SOURCE)
             .orElseLazy(() => context.getIf(P_PARTIAL_SOURCE).value)
-            .orElseLazy(() => context.getIf(CTX_PARAM_PASS_THR, P_PARTIAL_SOURCE).value).value;
+            .orElseLazy(() => context.getIf(CTX_PARAM_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

@@ -1,4 +1,4 @@
-/* Licensed to the Apache Software Foundation (ASF) under one or more
+/*! 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
@@ -32,6 +32,14 @@ export interface IResponseProcessor {
      */
     replaceHead(shadowHead: XMLQuery | DQ): void;
 
+
+    /**
+     * adds new elements to the head
+     *
+     * @param newElements the elements which need addition
+     */
+    addToHead(newElements: XMLQuery | DQ): void;
+
     /**
      * replace the body
      *
@@ -40,7 +48,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
      */
@@ -83,11 +91,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
@@ -98,34 +106,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;