jsf.js_next_gen 4.0.0-beta-16 → 4.0.0-beta-18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsf.js_next_gen",
-  "version": "4.0.0-beta-16",
+  "version": "4.0.0-beta-18",
   "description": "A next generation typescript reimplementation of jsf.js",
   "main": "dist/window/faces.js",
   "scripts": {

package/src/main/java/com/example/jsfs_js_ts/DecoratedFacesJS.java

@@ -25,6 +25,20 @@ import java.io.*;
 import java.net.URL;
 import java.util.Map;
 
+/**
+ * This class replicates a certain behavior we have
+ * in myfaces for the internal faces.js (which is based
+ * upon this projects code)
+ * MyFaces has a resource loader
+ * which replaces el constructs with their variable values, in faces.js
+ * We replicate this here in a somewhat hackish manner, atm
+ * only the context path is generated this way, because
+ * for other constructs which we use it we have pure js fallbacks
+ * delivering the same values
+ *
+ * You can use this class if you need or to provide the requestContextPath
+ * on js level (and extend it if you need to provide more)
+ */
 public class DecoratedFacesJS extends Resource {
 
     Resource delegate;

package/src/main/java/com/example/jsfs_js_ts/FacesJSMapFileResourceWrapper.java

@@ -0,0 +1,57 @@
+/* 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.
+ */
+package com.example.jsfs_js_ts;
+
+import jakarta.faces.application.Resource;
+import jakarta.faces.application.ResourceHandler;
+import jakarta.faces.application.ResourceHandlerWrapper;
+
+/**
+ * this class decorates a resource handler
+ * which dynamically adds the correct mapping data to the
+ * faces.js file depending on the configuration
+ *
+ * Note, you only need this class in your own projects, if you add
+ * the scripts to a Faces resource library.
+ * MyFaces itself has a similar mechanism in 4.0.0+ placed
+ * directly in the resource handler code.
+ */
+public class FacesJSMapFileResourceWrapper extends ResourceHandlerWrapper {
+    public FacesJSMapFileResourceWrapper(ResourceHandler delegate) {
+        super(delegate);
+    }
+
+    @Override
+    public Resource createResource(String resourceName) {
+        if (resourceName.contains("faces.js") || resourceName.contains("faces-development.js")) {
+            return new DecoratedFacesJS(super.createResource(resourceName));
+        }
+        return super.createResource(resourceName);
+    }
+
+    @Override
+    public Resource createResource(String resourceName, String libraryName) {
+        if (!resourceName.contains(".map") && (resourceName.contains("faces.js") || resourceName.contains("faces-development.js"))) {
+            return new FacesJSMappingDecorator(super.createResource(resourceName, libraryName));
+        }
+        return super.createResource(resourceName, libraryName);
+    }
+
+    @Override
+    public Resource createResource(String resourceName, String libraryName, String contentType) {
+        return super.createResource(resourceName, libraryName, contentType);
+    }
+}

package/src/main/java/com/example/jsfs_js_ts/FacesJSMappingDecorator.java

@@ -0,0 +1,138 @@
+/* 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.
+ */
+package com.example.jsfs_js_ts;
+
+import jakarta.faces.FacesException;
+import jakarta.faces.application.Resource;
+import jakarta.faces.context.FacesContext;
+
+import java.io.*;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.Map;
+
+/**
+ * The core implementation of the mapping file decoration.
+ * We basically rip out the old mapping file reference
+ * and add the new one, on the fly, when the resource is loaded.
+ */
+public class FacesJSMappingDecorator extends Resource {
+
+    public static final String URL_ENCODING = "UTF-8";
+    Resource delegate;
+
+    public FacesJSMappingDecorator(Resource delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public InputStream getInputStream() throws IOException {
+        try (
+                InputStream inputStream = delegate.getInputStream();
+                ByteArrayOutputStream writer = new ByteArrayOutputStream();
+        ) {
+            new BufferedReader(new InputStreamReader(inputStream))
+                    .lines()
+                    .forEach(line -> {
+                        if (line.contains("//# sourceMappingURL=")) {
+                            return;
+                        }
+                        try {
+                            writer.write(line.getBytes());
+                            writer.write("\n".getBytes());
+                        } catch (IOException e) {
+                            throw new FacesException(e);
+                        }
+                    });
+            // let´s add the decoration
+            String resourcePath = remapNames(delegate.getRequestPath());
+            resourcePath = resourcePath.substring(resourcePath.lastIndexOf("/") + 1);
+
+            writer.write("\n//# sourceMappingURL=".getBytes());
+            writer.write(resourcePath.getBytes());
+            return new ByteArrayInputStream(writer.toByteArray());
+        }
+    }
+
+    @Override
+    public String getRequestPath() {
+        return delegate.getRequestPath();
+    }
+
+    @Override
+    public Map<String, String> getResponseHeaders() {
+        return delegate.getResponseHeaders();
+    }
+
+    @Override
+    public URL getURL() {
+        try {
+            return remapNames(delegate.getURL());
+        } catch (MalformedURLException e) {
+            throw new FacesException(e);
+        }
+    }
+
+    @Override
+    public boolean userAgentNeedsUpdate(FacesContext context) {
+        return delegate.userAgentNeedsUpdate(context);
+    }
+
+    @Override
+    public String getContentType() {
+        return delegate.getContentType();
+    }
+
+    @Override
+    public String getLibraryName() {
+        return delegate.getLibraryName();
+    }
+
+    @Override
+    public String getResourceName() {
+        return remapNames(delegate.getResourceName());
+    }
+
+    @Override
+    public void setContentType(String contentType) {
+        delegate.setContentType(contentType);
+    }
+
+    @Override
+    public void setLibraryName(String libraryName) {
+        delegate.setLibraryName(libraryName);
+    }
+
+    @Override
+    public void setResourceName(String resourceName) {
+        delegate.setResourceName(resourceName);
+    }
+
+    @Override
+    public String toString() {
+        return delegate.toString();
+    }
+
+    private String remapNames(String in) {
+        return in.replace("faces-development.js", "faces-development.js.map")
+                .replace("faces.js", "faces.js.map");
+    }
+
+    private URL remapNames(URL in) throws MalformedURLException {
+        return new URL(in.toString().replace("faces-development.js", "faces-development.js.map")
+                .replace("faces.js", "faces.js.map"));
+    }
+}

package/src/main/typescript/@types/definitions/index.d.ts

@@ -0,0 +1,173 @@
+/* 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.
+ */
+
+/**
+ * Basic internal types used
+ *
+ * This file is only to eliminate various any calls into
+ * window, jsf and myfaces and make also the calls into
+ * the apis from a an extended window context in a type safe
+ * way
+ *
+ * We use this trick to map the types into the modules
+ * which we need to produce proper jsdoc files
+ */
+declare global {
+
+    type Producer<T> = () => T;
+    type Consumer<T> = (s?: T) => void;
+    type Runnable = () => any;
+    type Transformable<S, T> = (s: S) => T;
+
+    type AssocArr<T> = { [key: string]: T };
+
+    type EvalFuncs = Array<Function | string>;
+    type Options = { [key: string]: string | Function | { [key: string]: string | Function } };
+    type Context = AssocArr<any>;
+    type ElemDef = Element | string;
+
+
+    /**
+     *  * <ul>
+     *     <li> errorData.type : &quot;error&quot;</li>
+     *     <li> errorData.status : the error status message</li>
+     *     <li> errorData.serverErrorName : the server error name in case of a server error</li>
+     *     <li> errorData.serverErrorMessage : the server error message in case of a server error</li>
+     *     <li> errorData.source  : the issuing source element which triggered the requestInternal </li>
+     *     <li> eventData.responseCode: the response code (aka http requestInternal response code, 401 etc...) </li>
+     *     <li> eventData.responseText: the requestInternal response text </li>
+     *     <li> eventData.responseXML: the requestInternal response xml </li>
+     * </ul>
+     */
+    interface IErrorData {
+        type: any;
+        status: string;
+        serverErrorName: string;
+        serverErrorMessage: string;
+        source: any;
+
+        responseCode: string;
+        responseText: string;
+        responseXML: string;
+    }
+
+    /**
+     * <ul>
+     *     <li>status: status of the ajax cycle</li>
+     * </ul>
+     */
+    interface IEventData {
+        status: String;
+        source: any;
+    }
+
+    /*! 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.
+     */
+
+    /**
+     * interface definitions to make the code more compiler typesafe
+     */
+
+    interface Ajax {
+        request(element: Element, event?: Event, options?: Context): void;
+
+        response(request: XMLHttpRequest, context?: Context): void;
+    }
+
+    interface Util {
+        chain(source, event, ...funcs: Array<Function | string>): boolean;
+    }
+
+    interface Push {
+        init(socketClientId: string,
+             uri: string,
+             channel: string,
+             onopen: Function,
+             onmessage: Function,
+             onclose: Function,
+             behaviorScripts: any,
+             autoconnect: boolean): void;
+
+        open(socketClientId: string);
+
+        close(socketClientId: string): void;
+    }
+
+
+    interface FacesAPI {
+        contextpath: string;
+        specversion: number;
+        implversion: number;
+        separatorchar: string;
+
+        getProjectStage(): string;
+        getViewState(formElement: Element | string): string;
+        getClientWindow(rootNode?: Element | string): string;
+        getSeparatorChar(): string;
+        response(request: XMLHttpRequest, context?: Context): void;
+        addOnError(errorFunc: (data: IErrorData) => void): void;
+        addOnEvent(eventFunc: (data: IEventData) => void): void;
+
+        ajax: Ajax;
+        util: Util;
+        push: Push;
+    }
+
+    interface OAM {
+        clearHiddenInput(formName: string, name: string): void;
+        setHiddenInput(formName: string, name: string, value: string): void;
+        submitForm(formName: string, linkId: string, target: string, params: { [key: string]: any }): boolean;
+    }
+
+    interface MyFacesAPI {
+        ab(source: Element, event: Event, eventName: string, execute: string, render: string, options: Context): void;
+
+        config: { [key: string]: any };
+        oam: OAM;
+        core: {
+            config ?: {[key: string]: any};
+        };
+    }
+
+    let myfaces: MyFacesAPI;
+    let jsf: FacesAPI;
+    let faces: FacesAPI;
+    // special trick, the typscript compiler treats window as Window
+    interface Window {
+        myfaces: MyFacesAPI,
+        faces: FacesAPI,
+        jsf: FacesAPI,
+        XMLHttpRequest: XMLHttpRequest,
+        called: { [key: string]: any }
+    }
+}
+// this is needed to tell the compiler that we have an ambient
+// module, otherwise the global overload would produce an error
+// noinspection JSUnusedGlobalSymbols
+export var __my_faces_ambient_module_glob_;

package/src/main/typescript/api/_api.ts

@@ -17,14 +17,13 @@ import {Implementation} from "../impl/AjaxImpl";
 import {PushImpl} from "../impl/PushImpl";
 import {oam as _oam} from "../myfaces/OamSubmit";
 import {$nsp, CTX_PARAM_EXECUTE, CTX_PARAM_RENDER, P_BEHAVIOR_EVENT} from "../impl/core/Const";
+import {ErrorData} from "../impl/xhrCore/ErrorData";
+import {EventData} from "../impl/xhrCore/EventData";
 
-
-declare const window: any;
 //we use modules to get a proper jsdoc and static/map structure in the calls
 //as per spec requirement
 export module faces {
 
-    export var contextpath = '#{facesContext.externalContext.requestContextPath}';
 
     /**
      * Version of the implementation for the faces.ts.
@@ -101,7 +100,7 @@ export module faces {
     }
 
     //private helper functions
-    function getSeparatorChar() {
+    function getSeparatorChar(): string {
         const sep = '#{facesContext.namingContainerSeparatorChar}';
         //We now enable standalone mode, the separator char was not mapped we make a fallback to 2.3 behavior
         //the idea is that the separator char is provided from the underlying container, but if not then we
@@ -130,9 +129,8 @@ export module faces {
          * @param {EVENT} event: any javascript event supported by that object
          * @param {Map} options : map of options being pushed into the ajax cycle
          */
-        export function request(element: Element, event?: Event, options?: Context) {
+        export function request(element: Element, event?: Event, options?: Context): void {
             Implementation.request(element, event, options)
-            //Implementation.getInstance().requestInternal(element, event, options);
         }
 
         /**
@@ -142,7 +140,7 @@ export module faces {
          *
          * TODO add info on what can be in the context
          */
-        export function response(request: XMLHttpRequest, context?: Context) {
+        export function response(request: XMLHttpRequest, context?: Context): void {
             Implementation.response(request, context);
         }
 
@@ -163,7 +161,7 @@ export module faces {
          *
          * @param {function} errorListener error handler must be of the format <i>function errorListener(&lt;errorData&gt;)</i>
          */
-        export function addOnError(errorFunc: (data: ErrorData) => void) {
+        export function addOnError(errorFunc: (data: ErrorData) => void): void {
             Implementation.addOnError(<any>errorFunc);
         }
 
@@ -173,7 +171,7 @@ export module faces {
          *
          * @param {function} eventListener event must be of the format <i>function eventListener(&lt;eventData&gt;)</i>
          */
-        export function addOnEvent(eventFunc: (data: EventData) => void) {
+        export function addOnEvent(eventFunc: (data: EventData) => void): void {
             Implementation.addOnEvent(<any>eventFunc);
         }
     }
@@ -210,7 +208,7 @@ export module faces {
                     onmessage: Function,
                     onclose: Function,
                     behaviorScripts: any,
-                    autoconnect: boolean) {
+                    autoconnect: boolean): void {
             PushImpl.init(socketClientId, uri, channel, onopen, onmessage, onclose, behaviorScripts, autoconnect);
         }
 
@@ -219,7 +217,7 @@ export module faces {
          * @param {string} channel The name of the web socket channel.
          * @throws {Error} When channel is unknown.
          */
-        export function open(socketClientId: string) {
+        export function open(socketClientId: string): void {
             PushImpl.open(socketClientId);
         }
 
@@ -228,7 +226,7 @@ export module faces {
          * @param {string} channel The name of the web socket channel.
          * @throws {Error} When channel is unknown.
          */
-        export function close(socketClientId: string) {
+        export function close(socketClientId: string): void {
             PushImpl.close(socketClientId);
         }
 
@@ -248,7 +246,7 @@ export module myfaces {
      * @param render
      * @param options
      */
-    export function ab(source: Element, event: Event, eventName: string, execute: string, render: string, options: Context = {}) {
+    export function ab(source: Element, event: Event, eventName: string, execute: string, render: string, options: Context = {}): void {
         if (eventName) {
            options[$nsp(P_BEHAVIOR_EVENT)] = eventName;
         }

package/src/main/typescript/api/faces.ts

@@ -13,26 +13,31 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-///<reference types='../../types/typedefs'/>
-"use strict";
-import {Implementation} from "../impl/AjaxImpl";
 
-declare const window: any;
+"use strict";
 
 /**
  * faces.js init layer which provides as per spec the proper
  * window namespace if it does not exist already
+ *
+ * The idea is that we use a small shim on top of
+ * the implementation to provide the window namespace.
+ * The implementation itself is in a protected namespace
+ * which will be bound by the build system
+ *
+ * The documentation nevertheless targets the _api file, which
+ * hosts the full api
  */
 if(!window.faces) {
     //we lazily load the code to prevent ram bloat
     const faces = require("./_api").faces;
-    window['faces'] = (window as any)?.faces ?? faces;
+    window['faces'] = window?.faces ?? faces;
 }
 if(!window?.myfaces?.ab) {
     const myfaces = require("./_api").myfaces;
 
     //namespace might be extended is not exclusively reserved so we merge
-    window["myfaces"] = window?.myfaces ?? {};
+    (window as any)["myfaces"] = window?.myfaces ?? {};
     Object.keys(myfaces).forEach(key => window.myfaces[key] = window.myfaces?.[key] ?? myfaces[key]);
 }
 export var faces = window.faces;

package/src/main/typescript/api/jsf.ts

@@ -13,31 +13,28 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-///<reference types='../../types/typedefs'/>
-"use strict";
-
-declare const window: any;
 
+"use strict";
 /**
  * jsf.js init layer which provides as per spec the proper
  * window namespace if it does not exist already
  * if this file is included then the code falls back with its namespaces
  * on jsf2.3 or earlier level, for 4.0+ please include faces.js
  */
-if(!window.jsf) {
+if(!window?.jsf) {
     const faces = require("./_api").faces;
-    window['jsf'] = (window as any)?.jsf ?? faces;
+    (window as any)['jsf'] = window?.jsf ?? faces;
     window.jsf.specversion = 230000;
     delete window.jsf.contextpath;
 }
 if(!window?.myfaces?.ab) {
     const myfaces = require("./_api").myfaces;
     //namespace might be extended is not exclusively reserved so we merge
-    window["myfaces"] = window?.myfaces ?? {};
+    (window as any)["myfaces"] = window?.myfaces ?? {};
     if(!window?.myfaces?.ab) {
         const myfaces = require("./_api").myfaces;
         //namespace might be extended is not exclusively reserved so we merge
-        window["myfaces"] = window?.myfaces ?? {};
+        (window as any)["myfaces"] = window?.myfaces ?? {};
         Object.keys(myfaces).forEach(key => window.myfaces[key] = window.myfaces?.[key] ?? myfaces[key]);
     }
 }

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

@@ -25,6 +25,7 @@ import {ExtDomquery} from "./util/ExtDomQuery";
 import {ErrorData} from "./xhrCore/ErrorData";
 import {EventData} from "./xhrCore/EventData";
 import {ExtLang} from "./util/Lang";
+
 import {
     $nsp,
     CTX_PARAM_EXECUTE,
@@ -150,8 +151,6 @@ export module Implementation {
     import getGlobalConfig = ExtLang.getGlobalConfig;
     import assert = Assertions.assert;
 
-    declare const window: any;
-
     let projectStage: string = null;
     let separator: string = null;
     let eventQueue = [];

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

@@ -21,16 +21,14 @@
 //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";
+;
 
-declare const window: any;
 
 /**
  * Implementation class for the push functionality
  */
 export module PushImpl {
 
-
-
     const URL_PROTOCOL = window.location.protocol.replace("http", "ws") + "//";
 
 

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

@@ -172,9 +172,6 @@ export const MAX_RECONNECT_ATTEMPTS = 25;
 
 export const UNKNOWN = "UNKNOWN";
 
-declare const window: any;
-
-
 /**
  * helper to remap the namespaces variables for 2.3
  * from 2.3 to 4.0 every javax namespace has been changed

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

@@ -16,7 +16,7 @@
 import {Config, IValueHolder, Optional, DomQuery, DQ, Stream, ArrayCollector} from "mona-dish";
 import {$nsp, P_WINDOW_ID} from "../core/Const";
 
-declare let window: any;
+
 
 
 /**

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

@@ -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;
@@ -134,7 +135,7 @@ export module ExtLang {
          * 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;
     }
 
     /**
@@ -198,13 +199,12 @@ export module ExtLang {
      */
     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 +213,4 @@ export module ExtLang {
             throw makeException(new Error(), null, null, "Impl", "getForm", getMessage("ERR_FORM"));
         }
     }
-
 }

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

@@ -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;