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

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

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import {Config, IValueHolder, Optional, DomQuery, DQ, Stream, ArrayCollector} from "mona-dish";
+import {Config, IValueHolder, Optional, DomQuery, DQ} from "mona-dish";
 import {$nsp, P_WINDOW_ID} from "../core/Const";
 
 
@@ -39,9 +39,12 @@ const IS_FACES_SOURCE = (source?: string): boolean => {
 }
 
 /**
- * namespace myfaces.testscripts can be used as extension point for internal
- * tests, those will be handled similarly to faces.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
@@ -55,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 {
@@ -112,17 +115,15 @@ export class ExtDomquery extends DQ {
         let curScript = new DQ(document.currentScript);
         //since our baseline atm is ie11 we cannot use document.currentScript globally
         if (!!this.extractNonce(curScript)) {
-            // fastpath for modern browsers
+            // 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
+        let nonceScript = Optional.fromNullable(DQ
+            .querySelectorAll("script[src], link[src]").asArray
             .filter((item) => this.extractNonce(item)  && item.attr(ATTR_SRC) != null)
-            .filter(item => IS_FACES_SOURCE(item.attr(ATTR_SRC).value))
-            .first();
+            .filter(item => IS_FACES_SOURCE(item.attr(ATTR_SRC).value))?.[0]);
 
         if (nonceScript.isPresent()) {
             return this.extractNonce(nonceScript.value);
@@ -130,49 +131,45 @@ export class ExtDomquery extends DQ {
         return null;
     }
 
-
-
-    private extractNonce(curScript: DomQuery) {
-        return (curScript.getAsElem(0).value as HTMLElement)?.nonce ?? curScript.attr("nonce").value;
-    }
-
     static searchJsfJsFor(item: RegExp): Optional<String> {
-        return new ExtDomquery(document).searchJsfJsFor(item);
+        return new ExtDomQuery(document).searchJsfJsFor(item);
     }
 
     /**
-     * searches the embedded faces.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
+        return Optional.fromNullable(DQ.querySelectorAll("script[src], link[src]").asArray
             .filter(item => IS_FACES_SOURCE(item.attr(ATTR_SRC).value))
-            .map(item => item.attr(ATTR_SRC).value.match(rexp))
+            .map(item => item.attr(ATTR_SRC).value.match(regExp))
             .filter(item => item != null && item.length > 1)
             .map((result: string[]) => {
                 return decodeURIComponent(result[1]);
-            }).first();
+            })?.[0]);
     }
 
     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));
+        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 sticky if set to true the internally generated element for the script is left in the dom
-     * @param whilteListed
+     * @param whiteListed
      */
-    runScripts(sticky = false, whilteListed?: (src: string) => boolean): DomQuery {
+    runScripts(sticky = false, whiteListed?: (src: string) => boolean): DomQuery {
         const whitelistFunc = (src: string): boolean => {
-            return (whilteListed?.(src) ?? true) && !IS_FACES_SOURCE(src) && !IS_INTERNAL_SOURCE(src);
+            return (whiteListed?.(src) ?? true) && !IS_FACES_SOURCE(src) && !IS_INTERNAL_SOURCE(src);
         };
         return super.runScripts(sticky, whitelistFunc);
     }
@@ -183,7 +180,7 @@ export class ExtDomquery extends DQ {
      * @param suppressDoubleIncludes checks for existing elements in the head before running the insert
      */
     runHeadInserts(suppressDoubleIncludes = true): void {
-        let head = ExtDomquery.byId(document.head);
+        let head = ExtDomQuery.byId(document.head);
         //automated nonce handling
         let processedScripts = [];
 
@@ -197,12 +194,13 @@ export class ExtDomquery extends DQ {
             }
             const tagName = element.tagName.value;
             if(!tagName) {
-                // textnode
+                // 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);
+                .orElseLazy(() => element.attr("src").value)
+                .orElseLazy(() => element.attr("rel").value);
 
             if (!reference.isPresent()) {
                 return true;
@@ -217,14 +215,14 @@ export class ExtDomquery extends DQ {
             .each(element => {
                 if(element.tagName.value != "SCRIPT") {
                     //we need to run runScripts properly to deal with the rest
-                    new ExtDomquery(...processedScripts).runScripts(true);
+                    new ExtDomQuery(...processedScripts).runScripts(true);
                     processedScripts = [];
                     head.append(element);
                 } else {
                     processedScripts.push(element);
                 }
             });
-        new ExtDomquery(...processedScripts).runScripts(true);
+        new ExtDomQuery(...processedScripts).runScripts(true);
     }
 
 
@@ -235,15 +233,21 @@ 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);
+        return new ExtDomQuery(ret);
     }
 
+    private extractNonce(curScript: DomQuery) {
+        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;
+export const ExtDQ = ExtDomQuery;
 
 /**
  * in order to reduce the number of interception points for the fallbacks we add
@@ -251,18 +255,20 @@ export const ExtDQ = ExtDomquery;
  */
 export class ExtConfig extends  Config {
 
+    $nspEnabled = true;
+
     constructor(root: any) {
         super(root);
     }
 
     assignIf(condition: boolean, ...accessPath): IValueHolder<any> {
-        const acessPathMapped = this.remap(accessPath);
-        return super.assignIf(condition, ...acessPathMapped);
+        const accessPathMapped = this.remap(accessPath);
+        return super.assignIf(condition, ...accessPathMapped);
     }
 
     assign(...accessPath): IValueHolder<any> {
-        const acessPathMapped = this.remap(accessPath);
-        return super.assign(...acessPathMapped);
+        const accessPathMapped = this.remap(accessPath);
+        return super.assign(...accessPathMapped);
     }
 
     append(...accessPath): IValueHolder<any> {
@@ -270,13 +276,13 @@ export class ExtConfig extends  Config {
     }
 
     appendIf(condition: boolean, ...accessPath): IValueHolder<any> {
-        const acessPathMapped = this.remap(accessPath);
-        return super.appendIf(condition, ...acessPathMapped);
+        const accessPathMapped = this.remap(accessPath);
+        return super.appendIf(condition, ...accessPathMapped);
     }
 
     getIf(...accessPath): Config {
-        const acessPathMapped = this.remap(accessPath);
-        return super.getIf(...acessPathMapped);
+        const accessPathMapped = this.remap(accessPath);
+        return super.getIf(...accessPathMapped);
     }
 
     get(defaultVal: any): Config {
@@ -315,10 +321,15 @@ export class ExtConfig extends  Config {
         return new ExtConfig(super.deepCopy$());
     }
 
-
-    private remap(accessPath: any[]) {
-        return Stream.of(...accessPath).map(key => $nsp(key)).collect(new ArrayCollector());
+    /**
+     * 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: string[]): string[] {
+        if(!this.$nspEnabled) {
+            return accessPath;
+        }
+        return [...accessPath].map(key => $nsp(key));
     }
-
-
 }

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

@@ -0,0 +1,108 @@
+import {Config, DomQuery, DQ} from "mona-dish";
+import {ExtDomQuery} from "./ExtDomQuery";
+import {$faces, EMPTY_STR} from "../core/Const";
+
+/*
+ * various routines for encoding and decoding url parameters
+ * into configs and vice versa
+ */
+
+
+/**
+ * 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;
+    }
+    const assocValues = formData.value;
+
+    const expandValueArrAndRename = key => assocValues[key].map(val => paramsMapper(key, val));
+    const isPropertyKey = key => assocValues.hasOwnProperty(key);
+    const isNotFile = ([, value]) => !(value instanceof ExtDomQuery.global().File);
+    const mapIntoUrlParam = keyVal => `${encodeURIComponent(keyVal[0])}=${encodeURIComponent(keyVal[1])}`;
+
+    return Object.keys(assocValues)
+        .filter(isPropertyKey)
+        .flatMap(expandValueArrAndRename)
+        .filter(isNotFile)
+        .map(mapIntoUrlParam)
+        .join("&");
+}
+
+/**
+ * splits and decodes encoded values into strings containing of key=value
+ * @param encoded encoded string
+ */
+export function decodeEncodedValues(encoded: string): string[][] {
+    const filterBlanks = item => !!(item || '').replace(/\s+/g, '');
+    const splitKeyValuePair = line => {
+        let index = line.indexOf("=");
+        if (index == -1) {
+            return [line];
+        }
+        return [line.substring(0, index), line.substring(index + 1)];
+    };
+
+    let requestParamEntries = decodeURIComponent(encoded).split(/&/gi);
+    return requestParamEntries.filter(filterBlanks).map(splitKeyValuePair);
+}
+
+
+/**
+ * gets all the input files and their corresponding file objects
+ * @param dataSource
+ */
+export function resolveFiles(dataSource: DQ): [string, File][] {
+
+    const expandFilesArr = ([key, files]) => {
+        return [...files].map(file => [key, file]);
+    }
+    const remapFileInput = fileInput => {
+        return [fileInput.name.value || fileInput.id.value, fileInput.filesFromElem(0)];
+    }
+
+    const files = dataSource
+        .querySelectorAllDeep("input[type='file']")
+        .asArray;
+
+    const ret = files
+        .map(remapFileInput)
+        .flatMap(expandFilesArr);
+
+    return ret as any;
+}
+
+
+export function fixEmptyParameters(keyVal: any[]): [string, any] {
+    return (keyVal.length < 3 ? [keyVal?.[0] ?? [], keyVal?.[1] ?? []] : keyVal) as [string, any];
+}
+
+/**
+ * returns the decoded viewState from parentItem
+ * @param parentItem
+ */
+function resolveViewState(parentItem: DomQuery): string[][] | [string, File][] {
+    const viewStateStr = $faces().getViewState(parentItem.getAsElem(0).value);
+
+    // we now need to decode it and then merge it into the target buf
+    // which hosts already our overrides (aka do not override what is already there(
+    // after that we need to deal with form elements on a separate level
+    return decodeEncodedValues(viewStateStr);
+}
+
+/**
+ * gets all the inputs under the form parentItem
+ * as array
+ * @param parentItem
+ */
+export function getFormInputsAsArr(parentItem: DomQuery): string[][] | [string, File][] {
+    const standardInputs: any = resolveViewState(parentItem);
+    const fileInputs = resolveFiles(parentItem);
+    return standardInputs.concat(...fileInputs)
+}

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

@@ -0,0 +1,93 @@
+/*! 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.asArray.map(state => {
+            let ident: string = state.id.orElse("-1").value;
+            ident = ident.substring(ident.lastIndexOf(SEP)+1);
+            return parseInt(ident);
+        })
+            .filter(item => {
+                return !isNaN(item);
+            })
+            .reduce((item1, item2) => {
+                return Math.max(item1, item2);
+            }, -1);
+        //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;
+    }
+}