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

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "jsf.js_next_gen",
-  "version": "1.0.0-beta-20",
+  "version": "4.0.0-RC.1",
   "description": "A next generation typescript reimplementation of jsf.js",
-  "main": "dist/window/jsf.js",
+  "main": "dist/window/faces.js",
   "scripts": {
     "doc": "npx typedoc --tsconfig src/main/typescript/tsconfig-typedoc.json",
     "test": "env TS_NODE_PROJECT=./src/main/typescript/tsconfig.json mocha",
@@ -22,32 +22,32 @@
   "devDependencies": {
     "@istanbuljs/nyc-config-typescript": "^1.0.2",
     "@types/chai": "^4.3.3",
-    "@types/mocha": "^9.1.1",
-    "@types/node": "^18.7.18",
+    "@types/mocha": "^10.0.0",
+    "@types/node": "^18.11.9",
     "@types/sinon": "^10.0.13",
     "babel-plugin-syntax-dynamic-import": "^6.18.0",
     "chai": "^4.3.6",
     "compression-webpack-plugin": "^10.0.0",
     "html-webpack-plugin": "^5.5.0",
     "http-server": "^14.1.1",
-    "jsdom": "^20.0.0",
+    "jsdom": "^20.0.2",
     "jsdom-global": "^3.0.2",
-    "mocha": "^10.0.0",
-    "npm-check-updates": "^16.2.1",
+    "mocha": "^10.1.0",
+    "npm-check-updates": "^16.3.16",
     "nyc": "^15.1.0",
     "replace-in-file": "^6.3.5",
-    "rxjs": "^7.5.6",
-    "sinon": "^14.0.0",
+    "rxjs": "^7.5.7",
+    "sinon": "^14.0.1",
     "terser-webpack-plugin": "^5.3.6",
     "ts-loader": "^9.4.1",
     "ts-node": "^10.9.1",
-    "typedoc": "^0.23.15",
-    "typescript": "^4.8.3",
+    "typedoc": "^0.23.20",
+    "typescript": "^4.8.4",
     "webpack": "^5.74.0",
     "webpack-cli": "^4.10.0",
     "webpack-dev-server": "^4.11.1"
   },
   "dependencies": {
-    "mona-dish": "0.21.17"
+    "mona-dish": "0.23.5"
   }
 }

package/pom.xml

@@ -16,6 +16,7 @@
 
     <properties>
         <java.version>1.8</java.version>
+        <myfaces-version>4.0.0-SNAPSHOT</myfaces-version>
     </properties>
 
     <dependencies>
@@ -40,6 +41,19 @@
             <artifactId>spring-boot-starter-test</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.apache.myfaces.core</groupId>
+            <artifactId>myfaces-api</artifactId>
+            <version>${myfaces-version}</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.myfaces.core</groupId>
+            <artifactId>myfaces-impl</artifactId>
+            <version>${myfaces-version}</version>
+            <scope>provided</scope>
+        </dependency>
     </dependencies>
 
     <build>

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

@@ -0,0 +1,94 @@
+/*
+ * 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.context.FacesContext;
+
+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;
+
+    public DecoratedFacesJS(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()
+                    .map(line -> {
+                        //we theoretically could replace this with an el resolver
+                        //but for now checking for the exact pattern suffices
+                        String PATTERN = "#{facesContext.externalContext.requestContextPath}";
+                        return line != null && line.contains(PATTERN) ? line.replace(PATTERN, FacesContext.getCurrentInstance().getExternalContext().getRequestContextPath()) : line;
+                    }).forEach(line -> {
+                        try {
+                            writer.write(line.getBytes());
+                            writer.write("\n".getBytes());
+                        } catch (IOException e) {
+                            throw new RuntimeException(e);
+                        }
+                    });
+            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() {
+        return delegate.getURL();
+    }
+
+    @Override
+    public boolean userAgentNeedsUpdate(FacesContext context) {
+        return delegate.userAgentNeedsUpdate(context);
+    }
+}

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

@@ -0,0 +1,54 @@
+/*
+ * 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;
+
+/**
+ * a decorator which can be used to replace the templated variables in faces.js
+ * with their real world counterparts
+ */
+public class DecoratingResourceHandlerWrapper extends ResourceHandlerWrapper {
+    public DecoratingResourceHandlerWrapper(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("faces.js") || resourceName.contains("faces-development.js")) {
+            return new DecoratedFacesJS(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/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,147 @@
+/*! 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 there to allow global calls into window, faces and ajax
+ * in a typesafe manner, hence eliminating <b>any</b> casts.
+ */
+declare global {
+
+    type Consumer<T> = (s?: T) => void;
+    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;
+    }
+
+    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};
+        };
+    }
+
+    /*
+     * Global namespaces type definitions
+     */
+    let myfaces: MyFacesAPI;
+    let jsf: FacesAPI;
+    let faces: FacesAPI;
+
+    // special "magic", Typescript merges whatever we have
+    // to window. This is a language "hack", but documented.
+    // see https://www.typescriptlang.org/docs/handbook/declaration-files/templates/global-modifying-module-d-ts.html
+    // lib.dom.d.ts declares the type Window as being type for window.
+    // noinspection JSUnusedGlobalSymbols
+    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
+// https://www.typescriptlang.org/docs/handbook/declaration-files/templates/global-modifying-module-d-ts.html
+// noinspection JSUnusedGlobalSymbols
+export var __my_faces_ambient_module_glob_;