jsf.js_next_gen 4.0.1-beta.5 → 4.0.1-beta.7

package/target/types/main/typescript/Messaging.d.ts

@@ -0,0 +1,285 @@
+/*!
+ * 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.
+ */
+/**
+ * a standardized message to be sent over the message bus
+ */
+import { Observable, Subject } from "rxjs";
+/**
+ * generic crypto interface
+ * to encrypt messages before they are sent
+ * to the message bus oder the underlying bus system
+ *
+ * The idea is to make it as easy as possible, you can use for instance crypto js to
+ * handle everything
+ */
+export interface Crypto {
+    /**
+     * note anything can be passed
+     *
+     * @param data the data to be encrypted
+     * @returns the encrypted data in any format, important is decode must be able to handle it
+     */
+    encode(data: any): any;
+    /**
+     * @param data the encrypted data in the format you expect it to be
+     * @returns the unencrypted data
+     */
+    decode(data: any): any;
+}
+/**
+ * generic hash interface which provides
+ * exactly one method a hash encode which returns a string hash value of encoded data
+ */
+export interface Hash {
+    encode(encodedData: string): string;
+}
+/**
+ * Default implementation = no encryption
+ */
+export declare class NoCrypto implements Crypto {
+    decode(data: any): string;
+    encode(data: any): any;
+}
+export declare class Message {
+    message: any;
+    creationDate?: number;
+    identifier?: string;
+    targetOrigin?: string;
+    encoded: boolean;
+    constructor(message?: any, targetOrigin?: string);
+}
+/**
+ * abstract broker class
+ * (The broker is the central distribution unit of messages)
+ */
+declare abstract class BaseBroker {
+    static readonly EVENT_TYPE = "brokerEvent";
+    /**
+     * we can split the listeners with the system
+     * namespace... and type (aka identifier criteria)
+     */
+    protected messageListeners: any;
+    protected subjects: any;
+    protected processedMessages: any;
+    protected cleanupCnt: number;
+    protected rootElem: any;
+    protected msgHandler: any;
+    protected readonly TIMEOUT_IN_MS = 1000;
+    protected readonly MSG_EVENT = "message";
+    crypto: NoCrypto;
+    abstract register(scopeElement?: any): BaseBroker;
+    abstract unregister(): BaseBroker;
+    abstract broadcast(channel: string, message: Message | string): BaseBroker;
+    /**
+     * registers a listener on a channel
+     * @param channel the channel to register the listeners for
+     * @param listener the listener to register
+     */
+    registerListener(channel: string, listener: (msg: Message) => void): BaseBroker;
+    /**
+     * binding into rxjs
+     * produces a subject which can be used via next calls to send messages
+     * on the other hand we
+     * @param channel
+     */
+    asSubject(channel: string): Subject<Message>;
+    /**
+     * returns an observable on the baseBroker
+     * @param channel
+     */
+    asObservable(channel: string): Observable<Message>;
+    /**
+     * reserves the listener namespace and wildcard namespace for the given identifier
+     * @param identifier
+     * @private
+     */
+    private reserveListenerNS;
+    private reserveSubjectNS;
+    /**
+     * unregisters a listener from this channel
+     *
+     * @param channel the channel to unregister from
+     * @param listener the listener to unregister the channel from
+     */
+    unregisterListener(channel: string, listener: (msg: Message) => void): BaseBroker;
+    /**
+     * answers a bidirectional message received
+     * usage, the client can use this method, to answer an incoming message in a precise manner
+     * so that the caller sending the bidirectional message knows how to deal with it
+     * this mechanism can be used for global storages where we have one answering entity per channel delivering the
+     * requested data, the request can be done asynchronously via promises waiting for answers
+     *
+     * @param channel the channel the originating message
+     * @param request the requesting message
+     * @param answer the answer to the request
+     */
+    answer(channel: string, request: Message | string, answer: Message): BaseBroker;
+    private static getAnswerId;
+    private static isAnswer;
+    /**
+     * idea... a bidirectional broadcast
+     * sends a message and waits for the first answer coming in from one of the receivers
+     * sending the message back with a messageIdentifier_broadCastId answer
+     *
+     * @param channel
+     * @param message
+     */
+    request(channel: string, message: Message | string): Promise<Message>;
+    /**
+     * garbage collects the processed messages queue
+     * usually after one second
+     */
+    protected gcProcessedMessages(): void;
+    private messageStillActive;
+    protected markMessageAsProcessed(message: Message): void;
+}
+/**
+ * a broker which hooks into the Broadcast Channel
+ * either via shim or substitute lib
+ *
+ * The broadcast channels are a standardized messaging library
+ * The broker mechanism sets a layer on top to make it more manageable!
+ *
+ */
+export declare class BroadcastChannelBroker extends BaseBroker {
+    private brokerFactory;
+    private channelGroup;
+    crypto: Crypto;
+    private openChannels;
+    private readonly msgListener;
+    /**
+     * @param brokerFactory a factory generating a broker
+     * @param channelGroup a group to combine a set of channels
+     * @param crypto a crypto class
+     */
+    constructor(brokerFactory?: Function, channelGroup?: string, crypto?: Crypto);
+    broadcast(channel: string, message: Message | string, includeOrigin?: boolean): BaseBroker;
+    registerListener(channel: string, listener: (msg: Message) => void): BaseBroker;
+    register(): BaseBroker;
+    unregister(): BaseBroker;
+}
+/**
+ * Helper factory to create a broadcast channel broker
+ */
+export declare class BroadcastChannelBrokerBuilder {
+    private broadCastChannelGenerator;
+    private channelGroup;
+    private crypto;
+    private listeners;
+    withGeneratorFunc(generatorFunc: Function): BroadcastChannelBrokerBuilder;
+    withListener(channel: string, ...listeners: Function[]): BroadcastChannelBrokerBuilder;
+    withChannelGroup(channelGroup: string): BroadcastChannelBrokerBuilder;
+    withCrypto(crypto: Crypto): BroadcastChannelBrokerBuilder;
+    build(): BroadcastChannelBroker;
+}
+/**
+ * implementation of a messaging based transport
+ */
+/**
+ * central message broker which uses various dom constructs
+ * to broadcast messages into subelements
+ *
+ * we use the dom event system as transport and iframe and shadow dom mechanisms in a transparent way to
+ * pull this off
+ *
+ * usage
+ *
+ * broker = new Broker(optional rootElement)
+ *
+ * defines a message broker within a scope of rootElement (without it is window aka the current isolation level)
+ *
+ * broker.registerListener(channel, listener) registers a new listener to the current broker and channel
+ * broker.unregisterListener(channel, listener) unregisters the given listener
+ *
+ * broker.broadcast(message, optional direction, optional callBrokerListeners)
+ * sends a message (channel included in the message object) in a direction (up, down, both)
+ * and also optionally calls the listeners on the same broker (default off)
+ *
+ * the flow is like
+ * up messages are propagated upwards only until it reaches the outer top of the dom
+ * downwards, the messages are propagated downwards only
+ * both the message is propagated into both directions
+ *
+ * Usually messages sent from the same broker are not processed within... however by setting
+ * callBrokerListeners to true the listeners on the same broker also are called
+ * brokers on the same level will get the message and process it automatically no matter what.
+ * That way you can exclude the source from message processing (and it is done that way automatically)
+ *
+ * Isolation levels. Usually every isolation level needs its own broker object registering
+ * on the outer bounds
+ *
+ * aka documents will register on window
+ * iframes on the iframe windowObject
+ * isolated shadow doms... document
+ *
+ *
+ *
+ */
+export declare class Broker extends BaseBroker {
+    brokerGroup: string;
+    /**
+     * constructor has an optional root element
+     * and an internal name
+     *
+     * @param scopeElement
+     * @param brokerGroup
+     * @param crypto
+     */
+    constructor(scopeElement?: HTMLElement | Window | ShadowRoot, brokerGroup?: string, crypto?: Crypto);
+    /**
+     * register the current broker into a scope defined by wnd
+     * @param scopeElement
+     */
+    register(scopeElement: HTMLElement | Window | ShadowRoot): BaseBroker;
+    /**
+     * manual unregister function, to unregister as broker from the current
+     * scope
+     */
+    unregister(): BaseBroker;
+    /**
+     * broadcast a message
+     * the message contains the channel and the data and some internal bookkeeping data
+     *
+     * @param channel the channel to broadcast to
+     * @param message the message dot send
+     * (for instance 2 iframes within the same parent broker)
+     */
+    broadcast(channel: string, message: Message | string): BaseBroker;
+    private dispatchUp;
+    private dispatchSameLevel;
+    private dispatchDown;
+    private msgCallListeners;
+    private transformToEvent;
+    private static createCustomEvent;
+}
+/**
+ * Helper factory to create a dom broker
+ */
+export declare class BrokerBuilder {
+    private scopeElement;
+    private channelGroup;
+    private crypto;
+    private listeners;
+    withScopeElement(scopeElement: HTMLElement | Window | ShadowRoot): BrokerBuilder;
+    withListener(channel: string, ...listeners: Function[]): BrokerBuilder;
+    withChannelGroup(channelGroup: string): BrokerBuilder;
+    withCrypto(crypto: Crypto): BrokerBuilder;
+    build(): Broker;
+}
+export {};

package/target/types/main/typescript/Monad.d.ts

@@ -0,0 +1,161 @@
+/*!
+ * 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.
+ */
+/**
+ * IFunctor interface,
+ * defines an interface which allows to map a functor
+ * via a first order function to another functor
+ */
+export interface IFunctor<T> {
+    map<R>(fn: (data: T) => R): IFunctor<R>;
+}
+/**
+ * IMonad definition, basically a functor with a flatMap implementation, flatMap reduces all nested monads after a
+ * function call f into a monad with the nesting level of 1
+ *
+ * flatmap flats nested Monads into a IMonad of the deepest nested implementation
+ */
+export interface IMonad<T, M extends IMonad<any, any>> extends IFunctor<T> {
+    flatMap<T, M>(f: (T: any) => M): IMonad<any, any>;
+}
+/**
+ * a stateful functor which holds a value upn which a
+ * function can be applied
+ *
+ * as value holder of type T
+ */
+export interface IIdentity<T> extends IFunctor<T> {
+    readonly value: T;
+}
+/**
+ *  custom value holder definition, since we are not pure functional
+ *  but iterative we have structures which allow the assignment of a value
+ *  also not all structures are side - effect free
+ */
+export interface IValueHolder<T> {
+    value: T | Array<T>;
+}
+/**
+ * Implementation of a monad
+ * (Side - effect free), no write allowed directly on the monads
+ * value state
+ */
+export declare class Monad<T> implements IMonad<T, Monad<any>>, IValueHolder<T> {
+    constructor(value: T);
+    protected _value: T;
+    get value(): T;
+    map<R>(fn?: (data: T) => R): Monad<R>;
+    flatMap<R>(fn?: (data: T) => R): Monad<any>;
+}
+/**
+ * optional implementation, an optional is basically an implementation of a Monad with additional syntactic
+ * sugar on top
+ * (Side - effect free, since value assignment is not allowed)
+ * */
+export declare class Optional<T> extends Monad<T> {
+    static absent: Optional<any>;
+    constructor(value: T);
+    get value(): T;
+    static fromNullable<V extends Optional<T>, T>(value?: T): Optional<T>;
+    isAbsent(): boolean;
+    /**
+     * any value present
+     */
+    isPresent(presentRunnable?: (val?: Monad<T>) => void): boolean;
+    ifPresentLazy(presentRunnable?: (val?: Monad<T>) => void): Monad<T>;
+    orElse(elseValue: any): Optional<any>;
+    /**
+     * lazy, passes a function which then is lazily evaluated
+     * instead of a direct value
+     * @param func
+     */
+    orElseLazy(func: () => any): Optional<any>;
+    flatMap<R>(fn?: (data: T) => R): Optional<any>;
+    getIf<R>(...key: string[]): Optional<R>;
+    /**
+     * simple match, if the first order function call returns
+     * true then there is a match, if the value is not present
+     * it never matches
+     *
+     * @param fn the first order function performing the match
+     */
+    match(fn: (item: T) => boolean): boolean;
+    /**
+     * convenience function to flatmap the internal value
+     * and replace it with a default in case of being absent
+     *
+     * @param defaultVal
+     * @returns {Optional<any>}
+     */
+    get<R>(defaultVal?: any): Optional<R>;
+    toJson(): string;
+    /**
+     * helper to override several implementations in a more fluent way
+     * by having a getClass operation we can avoid direct calls into the constructor or
+     * static methods and do not have to implement several methods which rely on the type
+     * of "this"
+     * @returns the type of Optional
+     */
+    protected getClass(): any;
+    protected arrayIndex(key: string): number;
+    protected keyVal(key: string): string;
+    /**
+     * additional syntactic sugar which is not part of the usual optional implementation
+     * but makes life easier, if you want to sacrifice typesafety and refactoring
+     * capabilities in typescript
+     */
+    getIfPresent<R>(key: string): Optional<R>;
+    /**
+     * elvis like typesafe functional save resolver
+     * a typesafe option for getIfPresent
+     *
+     * usage myOptional.resolve(value => value.subAttr.subAttr2).orElseLazy(....)
+     * if this is resolvable without any errors an Optional with the value is returned
+     * if not, then an Optional absent is returned, also if you return Optional absent
+     * it is flatmapped into absent
+     *
+     * @param resolver the resolver function, can throw any arbitrary errors, int  the error case
+     * the resolution goes towards absent
+     */
+    resolve<V>(resolver: (item: T) => V): Optional<V>;
+    protected preprocessKeys(...keys: any[]): string[];
+}
+/**
+ * ValueEmbedder is the writeable version
+ * of optional, it basically is a wrapper
+ * around a construct which has a state
+ * and can be written to.
+ *
+ * For the readonly version see Optional
+ */
+export declare class ValueEmbedder<T> extends Optional<T> implements IValueHolder<T> {
+    static absent: Optional<unknown>;
+    protected key: string;
+    constructor(rootElem: any, valueKey?: string);
+    get value(): T;
+    set value(newVal: T);
+    orElse(elseValue: any): Optional<any>;
+    orElseLazy(func: () => any): Optional<any>;
+    /**
+     * helper to override several implementations in a more fluent way
+     * by having a getClass operation we can avoid direct calls into the constructor or
+     * static methods and do not have to implement several methods which rely on the type
+     * of "this"
+     * @returns ValueEmbedder
+     */
+    protected getClass(): any;
+    static fromNullable<V extends Optional<T>, T>(value?: any, valueKey?: string): V;
+}

package/target/types/main/typescript/Promise.d.ts

@@ -0,0 +1,58 @@
+export declare enum PromiseStatus {
+    PENDING = 0,
+    FULLFILLED = 1,
+    REJECTED = 2
+}
+export interface IPromise {
+    then(executorFunc: (val: any) => any): IPromise;
+    catch(executorFunc: (val: any) => any): IPromise;
+    finally(executorFunc: () => void): IPromise;
+}
+export declare function timeout(timeout: number): CancellablePromise;
+export declare function interval(timeout: number): CancellablePromise;
+/**
+ * a small (probably not 100% correct, although I tried to be correct as possible) Promise implementation
+ * for systems which do not have a promise implemented
+ * Note, although an internal state is kept, this is sideffect free since
+ * is value is a function to operate on, hence no real state is kept internally, except for the then
+ * and catch calling order
+ */
+export declare class Promise implements IPromise {
+    status: PromiseStatus;
+    protected allFuncs: Array<any>;
+    private value;
+    constructor(executor: (resolve: (val?: any) => void, reject: (val?: any) => void) => void);
+    static all(...promises: Array<IPromise>): IPromise;
+    static race(...promises: Array<IPromise>): IPromise;
+    static reject(reason: any): Promise;
+    static resolve(reason: any): Promise;
+    then(executorFunc: (val?: any) => any, catchfunc?: (val?: any) => any): Promise;
+    catch(executorFunc: (val?: any) => void): Promise;
+    finally(executorFunc: () => void): Promise;
+    protected resolve(val?: any): void;
+    protected reject(val?: any): void;
+    protected appyFinally(): void;
+    private spliceLastFuncs;
+    private transferIntoNewPromise;
+}
+/**
+ * a cancellable promise
+ * a Promise with a cancel function, which can be cancellend any time
+ * this is useful for promises which use cancellable asynchronous operations
+ * note, even in a cancel state, the finally of the promise is executed, however
+ * subsequent thens are not anymore.
+ * The current then however is fished or a catch is called depending on how the outer
+ * operation reacts to a cancel order.
+ */
+export declare class CancellablePromise extends Promise {
+    /**
+     * @param executor asynchronous callback operation which triggers the callback
+     * @param cancellator cancel operation, separate from the trigger operation
+     */
+    constructor(executor: (resolve: (val?: any) => void, reject: (val?: any) => void) => void, cancellator: () => void);
+    cancel(): void;
+    then(executorFunc: (val?: any) => any, catchfunc?: (val?: any) => any): CancellablePromise;
+    catch(executorFunc: (val?: any) => void): CancellablePromise;
+    finally(executorFunc: () => void): CancellablePromise;
+    private cancellator;
+}

package/target/types/main/typescript/PromiseShim.d.ts

@@ -0,0 +1,22 @@
+/*!
+ * 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.
+ */
+/**
+ * Promise shim which uses our Promise implementation in the window context
+ */
+export {};