jsf.js_next_gen 4.1.0-beta.2 → 4.1.0-beta.21

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

@@ -17,13 +17,62 @@ import {Implementation} from "../impl/AjaxImpl";
 import {PushImpl} from "../impl/PushImpl";
 import {oam as _oam} from "../myfaces/OamSubmit";
 import {$nsp, CTX_OPTIONS_EXECUTE, CTX_OPTIONS_PARAMS, CTX_PARAM_RENDER, P_BEHAVIOR_EVENT} from "../impl/core/Const";
-import {ErrorData} from "../impl/xhrCore/ErrorData";
-import {EventData} from "../impl/xhrCore/EventData";
 
 //we use modules to get a proper jsdoc and static/map structure in the calls
 //as per spec requirement
 export namespace faces {
 
+    /**
+     * Project stage values, mirroring jakarta.faces.application.ProjectStage.
+     */
+    export type ProjectStage = "Development" | "UnitTest" | "SystemTest" | "Production";
+
+    /**
+     * Status values sent to ajax event callbacks.
+     */
+    export type AjaxEventStatus = "begin" | "complete" | "success";
+
+    /**
+     * Status values sent to ajax error callbacks.
+     */
+    export type AjaxErrorStatus = "httpError" | "emptyResponse" | "malformedXML" | "serverError";
+
+    /**
+     * Common shape for the data passed to ajax callbacks.
+     */
+    export interface AjaxData {
+        source?: Element;
+        responseCode?: number;
+        responseText?: string;
+        responseXML?: XMLDocument;
+    }
+
+    /**
+     * Data passed to ajax event callbacks.
+     */
+    export interface AjaxEvent extends AjaxData {
+        type: "event";
+        status: AjaxEventStatus;
+    }
+
+    /**
+     * Data passed to ajax error callbacks.
+     */
+    export interface AjaxError extends AjaxData {
+        type: "error";
+        status: AjaxErrorStatus | "clientError" | "timeout";
+        errorName?: string;
+        errorMessage?: string;
+        /** @deprecated MyFaces compatibility alias. */
+        serverErrorName?: string;
+        /** @deprecated MyFaces compatibility alias. */
+        serverErrorMessage?: string;
+        /** MyFaces compatibility detail. */
+        description?: string;
+        /** MyFaces compatibility detail. */
+        typeDetails?: unknown;
+    }
+
 
     /**
      * Version of the implementation for the faces.ts.
@@ -35,7 +84,7 @@ export namespace faces {
      * <li>right two digits bug release number</li>
      * </ul>
      */
-    export var specversion = 400000;
+    export const specversion: number = 400000;
     /**
      * Implementation version as specified within the jsf specification.
      * <p />
@@ -43,18 +92,18 @@ export namespace faces {
      * and reset by moving to a new spec release number
      *
      */
-    export var implversion = 0;
+    export const implversion: number = 0;
 
     /**
      * SeparatorChar as defined by facesContext.getNamingContainerSeparatorChar()
      */
-    export var separatorchar: string = getSeparatorChar();
+    export const separatorchar: string = getSeparatorChar();
 
     // noinspection JSUnusedGlobalSymbols
     /**
      * Context Path as defined externalContext.requestContextPath
      */
-    export var contextpath: string = '#{facesContext.externalContext.requestContextPath}';
+    export const contextpath: string = '#{facesContext.externalContext.requestContextPath}';
     // we do not have a fallback here, for now
 
     /**
@@ -72,8 +121,8 @@ export namespace faces {
      * @return {String} the current project state emitted by the server side method:
      * <i>jakarta.faces.application.Application.getProjectStage()</i>
      */
-    export function getProjectStage(): string {
-        return Implementation.getProjectStage();
+    export function getProjectStage(): ProjectStage {
+        return Implementation.getProjectStage() as ProjectStage;
     }
 
     /**
@@ -93,7 +142,7 @@ export namespace faces {
      * @return the window identifier or null if none is found
      * @param rootNode
      */
-    export function getClientWindow(rootNode?: Element | string): string {
+    export function getClientWindow(rootNode?: Element | string): string | null {
         return Implementation.getClientWindow(rootNode);
     }
 
@@ -112,6 +161,42 @@ export namespace faces {
     export namespace ajax {
         "use strict";
 
+        /**
+         * Callback signature for ajax lifecycle events.
+         */
+        export type OnEventCallback = (data: AjaxEvent) => void;
+
+        /**
+         * Callback signature for ajax errors.
+         */
+        export type OnErrorCallback = (data: AjaxError) => void;
+
+        /**
+         * Options object for faces.ajax.request.
+         */
+        export interface RequestOptions {
+            execute?: string;
+            render?: string;
+            onevent?: OnEventCallback;
+            onerror?: OnErrorCallback;
+            params?: Record<string, string | number | boolean>;
+            delay?: number | "none";
+            resetValues?: boolean;
+            /** MyFaces extension/pass-through compatibility. */
+            [key: string]: any;
+        }
+
+        /**
+         * Per-request context object passed to faces.ajax.response.
+         */
+        export interface RequestContext {
+            sourceid?: string;
+            onerror?: OnErrorCallback;
+            onevent?: OnEventCallback;
+            /** MyFaces extension/pass-through compatibility. */
+            [key: string]: any;
+        }
+
         /**
          * this function has to send the ajax requests
          *
@@ -127,8 +212,8 @@ export namespace 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?: Options): void {
-            Implementation.request(element, event, options)
+        export function request(element: Element | string, event?: Event | null, options?: RequestOptions): void {
+            Implementation.request(element, event as any, options as any)
         }
 
         /**
@@ -137,8 +222,8 @@ export namespace faces {
          * @param context the request context
          *
          */
-        export function response(request: XMLHttpRequest, context?: Context): void {
-            Implementation.response(request, context);
+        export function response(request: XMLHttpRequest, context?: RequestContext): void {
+            Implementation.response(request, context as any);
         }
 
         /**
@@ -158,7 +243,7 @@ export namespace faces {
          *
          * @param errorFunc error handler must be of the format <i>function errorListener(&lt;errorData&gt;)</i>
          */
-        export function addOnError(errorFunc: (data: ErrorData) => void): void {
+        export function addOnError(errorFunc: OnErrorCallback): void {
             Implementation.addOnError(errorFunc as any);
         }
 
@@ -168,7 +253,7 @@ export namespace faces {
          *
          * @param eventFunc event must be of the format <i>function eventListener(&lt;eventData&gt;)</i>
          */
-        export function addOnEvent(eventFunc: (data: EventData) => void): void {
+        export function addOnEvent(eventFunc: OnEventCallback): void {
             Implementation.addOnEvent(eventFunc as any);
         }
     }
@@ -186,12 +271,32 @@ export namespace faces {
          * @param funcs ... arbitrary array of functions or strings
          * @returns true if the chain has succeeded false otherwise
          */
-        export function chain(source: HTMLElement | string, event: Event | null, ...funcs: Array<Function | string>): boolean {
-            return Implementation.chain(source, event, ...(funcs as EvalFuncs));
+        export function chain(source: HTMLElement | string, event?: Event | null, ...funcs: Array<Function | string>): boolean {
+            return Implementation.chain(source, event ?? null, ...(funcs as EvalFuncs));
         }
     }
 
     export namespace push {
+        /**
+         * Invoked when the websocket is opened.
+         */
+        export type OnOpenHandler = (channel: string) => void;
+
+        /**
+         * Invoked when a message is received from the server.
+         */
+        export type OnMessageHandler = (message: unknown, channel: string, event: MessageEvent) => void;
+
+        /**
+         * Invoked when a connection error occurs and the websocket will attempt to reconnect.
+         */
+        export type OnErrorHandler = (code: number, channel: string, event: CloseEvent) => void;
+
+        /**
+         * Invoked when the websocket is closed and will not attempt to reconnect.
+         */
+        export type OnCloseHandler = (code: number, channel: string, event: CloseEvent) => void;
+
         /**
          * @param socketClientId the sockets client identifier
          * @param url the uri to reach the socket
@@ -206,13 +311,13 @@ export namespace faces {
         export function init(socketClientId: string,
                              url: string,
                              channel: string,
-                             onopen: Function,
-                             onmessage: Function,
-                             onerror: Function,
-                             onclose: Function,
-                             behaviors: any,
+                             onopen: OnOpenHandler | string | null,
+                             onmessage: OnMessageHandler | string | null,
+                             onerror: OnErrorHandler | string | null,
+                             onclose: OnCloseHandler | string | null,
+                             behaviors: Record<string, Array<() => void>>,
                              autoConnect: boolean): void {
-            PushImpl.init(socketClientId, url, channel, onopen, onmessage, onerror, onclose, behaviors, autoConnect);
+            PushImpl.init(socketClientId, url, channel, onopen as any, onmessage as any, onerror as any, onclose as any, behaviors, autoConnect);
         }
 
         /**
@@ -250,7 +355,7 @@ export namespace myfaces {
      * @param options the options which need to be merged in
      * @param userParameters a set of user parameters which go into the final options under params, they can override whatever is passed via options
      */
-    export function ab(source: Element, event: Event, eventName: string, execute: string, render: string, options: Options = {}, userParameters: Options = {}): void {
+    export function ab(source: Element, event: Event, eventName: string, execute: string, render: string, options: faces.ajax.RequestOptions = {}, userParameters: faces.ajax.RequestOptions = {}): void {
         if(!options) {
             options = {};
         }
@@ -277,12 +382,12 @@ export namespace myfaces {
             options["params"][key] = userParameters[key];
         }
 
-        (window?.faces ?? window.jsf).ajax.request(source, event, options);
+        (window?.faces ?? window.jsf).ajax.request(source, event, options as any);
     }
 
 
     const onReadyChain: Array<() => void> = [];
-    let readyStateListener = null;
+    let readyStateListener: (() => void) | null = null;
     // noinspection JSUnusedGlobalSymbols
     /**
      * Helper function in the myfaces namespace to handle document ready properly for the load case
@@ -296,7 +401,7 @@ export namespace myfaces {
             onReadyChain.push(executionFunc);
             if(!readyStateListener) {
                 readyStateListener = () => {
-                    window.removeEventListener("DOMContentLoaded", readyStateListener);
+                    window.removeEventListener("DOMContentLoaded", readyStateListener!);
                     readyStateListener = null;
                     try {
                         onReadyChain.forEach(func => func());
@@ -334,5 +439,3 @@ export namespace myfaces {
      */
     export const oam = _oam;
 }
-
-

package/{target/test/frameworkBase/_ext/monadish/fixtures/test.js → src/main/typescript/api/_api_ae_stub.d.ts}

@@ -13,5 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-document.getElementById('id_1').innerHTML = "hello world";
-//# sourceMappingURL=test.js.map
+
+// Stub file consumed only by tsconfig.ae.json (api-extractor's compiler config).
+// api-extractor uses mainEntryPointFilePath (target/dts/_api.d.ts) as the real
+// entry — this file exists solely to satisfy TypeScript's "at least one input"
+// requirement without pulling any source .ts files into the compiler program.
+export {};

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

@@ -30,8 +30,8 @@
  */
 if(!window.faces) {
     //we lazily load the code to prevent ram bloat
-    const faces = require("./_api").faces;
-    window['faces'] = window?.faces ?? faces;
+    const myfacesApi = require("./_api").faces;
+    window['faces'] = window?.faces ?? myfacesApi;
 }
 if(!window?.myfaces?.ab) {
     const myfaces = require("./_api").myfaces;

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

@@ -22,40 +22,32 @@
  * on jsf2.3 or earlier level, for 4.0+ please include faces.js
  */
 if(!window?.jsf) {
-    const faces = require("./_api").faces;
-    (window as any)['jsf'] = window?.jsf ?? faces;
+    const myfacesApi = require("./_api").faces;
+    (window as any)['jsf'] = window?.jsf ?? {...myfacesApi, push: {...myfacesApi.push}};
     window.jsf.specversion = 230000;
-    delete window.jsf.contextpath;
+    delete (window.jsf as Partial<typeof window.jsf>).contextpath;
 
-    let faces4Init = faces.push.init;
     /*
      * we shim back the breaking api change from 3.0 to 4.0
-     * onerror is gone
+     * JSF 2.3 did not expose a websocket onerror callback.
      */
-    faces.push.init = (socketClientId: string,
-                       url: string,
-                       channel: string,
-                       onopen: Function,
-                       onmessage: Function,
-                       // no on error api change for 4.0
-                       //onerror: Function,
-                       onclose: Function,
-                       behaviors: any,
-                       autoConnect: boolean) => {
-        faces4Init(socketClientId, url, channel, onopen, onmessage, null, onclose, behaviors, autoConnect);
+    window.jsf.push.init = (socketClientId: string,
+                            url: string,
+                            channel: string,
+                            onopen: Function,
+                            onmessage: Function,
+                            onclose: Function,
+                            behaviors: any,
+                            autoConnect: boolean) => {
+        myfacesApi.push.init(socketClientId, url, channel, onopen, onmessage, null, onclose, behaviors, autoConnect);
     }
 }
 if(!window?.myfaces?.ab) {
     const myfaces = require("./_api").myfaces;
     //namespace might be extended is not exclusively reserved so we merge
     (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 as any)["myfaces"] = window?.myfaces ?? {};
-        Object.keys(myfaces).forEach(key => window.myfaces[key] = window.myfaces?.[key] ?? myfaces[key]);
-    }
+    Object.keys(myfaces).forEach(key => window.myfaces[key] = window.myfaces?.[key] ?? myfaces[key]);
 }
 
 export var jsf = window.jsf;
-export var myfaces = window.myfaces;
+export var myfaces = window.myfaces;

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

@@ -159,11 +159,11 @@ export namespace Implementation {
     const ofAssoc = ExtLang.ofAssoc;
     const collectAssoc = ExtLang.collectAssoc;
 
-    let projectStage: string = null;
-    let separator: string = null;
-    let eventQueue = [];
-    let errorQueue = [];
-    export let requestQueue: XhrQueueController<XhrRequest> = null;
+    let projectStage: string | null = null;
+    let separator: string | null = null;
+    let eventQueue: Function[] = [];
+    let errorQueue: Function[] = [];
+    export let requestQueue: XhrQueueController<XhrRequest> | null = null;
     /*error reporting threshold*/
     let threshold = "ERROR";
 
@@ -217,7 +217,7 @@ export namespace Implementation {
      * @param event
      * @param funcs
      */
-    export function chain(source: any, event: Event, ...funcs: EvalFuncs): boolean {
+    export function chain(source: any, event: Event | null, ...funcs: EvalFuncs): boolean {
         // we can use our lazy stream each functionality to run our chain here.
         // by passing a boolean as return value into the onElem call
         // we can stop early at the first false, just like the spec requests
@@ -444,7 +444,7 @@ export namespace Implementation {
             }
         } finally {
             if (clearRequestQueue) {
-                requestQueue.clear();
+                requestQueue?.clear();
             }
         }
     }
@@ -472,7 +472,7 @@ export namespace Implementation {
         errorQueue.forEach((errorCallback: Function) => {
             errorCallback(errorData);
         });
-        let displayError: (string) => void = getGlobalConfig("defaultErrorOutput", (console ? console.error : alert));
+        let displayError: (message: any) => void = getGlobalConfig("defaultErrorOutput", (console ? console.error : alert));
         displayError(errorData);
     }
 
@@ -497,12 +497,12 @@ export namespace Implementation {
         /*
          * lazy helper to fetch the window id from the included faces.js
          */
-        let fetchWindowIdFromJSFJS = (): Optional<string> => ExtDomQuery.searchJsfJsFor(/jfwid=([^&;]*)/).orElse(null);
+        let fetchWindowIdFromJSFJS = (): Optional<string | null> => ExtDomQuery.searchJsfJsFor(/jfwid=([^&;]*)/).orElse(null);
 
         /*
          * fetch window id from the url
          */
-        let fetchWindowIdFromURL = function (): Optional<string> {
+        let fetchWindowIdFromURL = function (): Optional<string | null> {
             const href = window.location.href, windowId = "jfwid";
             const regex = new RegExp("[\\?&]" + windowId + "=([^&#\\;]*)");
             const results = regex.exec(href);
@@ -696,7 +696,7 @@ export namespace Implementation {
         //a cleaner implementation of the transform list method
         const SEP = $faces().separatorchar;
         let iterValues: string[] = (userValues) ? trim(userValues).split(/\s+/gi) : [];
-        let ret = [];
+        let ret: string[] = [];
         let processed: {[key: string]: boolean} = {};
 
         /**
@@ -706,7 +706,7 @@ export namespace Implementation {
          * apparently the RI does not, so we have to follow the RI behavior here)
          * @param componentIdToTransform the componentId which needs post-processing
          */
-        const remapNamingContainer = componentIdToTransform => {
+        const remapNamingContainer = (componentIdToTransform: string) => {
             // pattern :<anything> must be prepended by viewRoot if there is one,
             // otherwise we are in a not namespaced then only the id has to match
             const rootNamingContainerPrefix = (rootNamingContainerId.length) ? rootNamingContainerId+SEP : EMPTY_STR;
@@ -795,7 +795,7 @@ export namespace Implementation {
         //we now can use the full code reduction given by our stream api
         //to filter
         return ofAssoc(mappedOpts)
-            .filter((item => !(item[0] in BlockFilter)))
+            .filter(((item: [string, any]) => !(item[0] in BlockFilter)))
             .reduce(collectAssoc, {});
     }
 
@@ -810,7 +810,7 @@ export namespace Implementation {
         //we now can use the full code reduction given by our stream api
         //to filter
         return ofAssoc(mappedOpts)
-            .filter((item => (item[0] == "myfaces")))
+            .filter(((item: [string, any]) => (item[0] == "myfaces")))
             .reduce(collectAssoc, {})?.[MYFACES];
     }
 
@@ -835,7 +835,7 @@ export namespace Implementation {
      * caller is basically notified that the execution can now stop (JSF requirement for chain)
      * @private
      */
-    function resolveAndExecute(source: any, event: Event, func: Function | string): boolean {
+    function resolveAndExecute(source: any, event: Event | null, func: Function | string): boolean {
         if ("string" != typeof func) {
             //function is passed down as chain parameter, can be executed as is
             return (<Function>func).call(source, event) !== false;