jsf.js_next_gen 4.0.1-beta.9 → 4.0.2-beta.2

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

@@ -1,280 +0,0 @@
-/*!
- * 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 } from "./DomQuery";
-import { Config } from "./Config";
-/**
- * special status of the datasource location pointer
- * if an access, outside - of the possible data boundaries is happening
- * (example for instance current without a first next call, or next
- * which goes over the last possible dataset), an iteration status return
- * value is returned marking this boundary instead of a classical element
- *
- * Note this is only internally used but must be implemented to fulfill
- * internal contracts, the end user will never see those values if he uses
- * streams!
- */
-export declare enum ITERATION_STATUS {
-    EO_STRM = "__EO_STRM__",
-    BEF_STRM = "___BEF_STRM__"
-}
-export declare function calculateSkips(next_strm: IStreamDataSource<any>): number;
-/**
- * Every data source wich feeds data into the lazy stream
- * or stream generally must implement this interface
- *
- * It is basically an iteratable to the core
- */
-export interface IStreamDataSource<T> {
-    /**
-     * @returns true if additional data is present false if not
-     */
-    hasNext(): boolean;
-    /**
-     * returns the next element in the stream
-     */
-    next(): T | ITERATION_STATUS;
-    /**
-     * looks ahead cnt without changing the internal data "pointers" of the data source
-     * (this is mostly needed by possibly infinite constructs like lazy streams,
-     * because they do not know by definition their
-     * boundaries)
-     *
-     * @param cnt the elements to look ahead
-     * @return either the element or ITERATION_STATUS.EO_STRM if we hit the end of the stream before
-     * finding the "cnt" element
-     */
-    lookAhead(cnt?: number): T | ITERATION_STATUS;
-    /**
-     * returns the current element, returns the same element as the previous next call
-     * if there is no next before current called then we will call next as initial element
-     */
-    current(): T | ITERATION_STATUS;
-    /**
-     * resets the position to the beginning
-     */
-    reset(): void;
-}
-/**
- * A collector, needs to be implemented
- */
-export interface ICollector<T, S> {
-    /**
-     * this method basically takes a single stream element
-     * and does something with it (collecting it one way or the other
-     * in most cases)
-     *
-     * @param element
-     */
-    collect(element: T): any;
-    /**
-     * the final result after all the collecting is done
-     */
-    finalValue: S;
-}
-/**
- * A data source which combines multiple streams sequentially into one
- * (this is used internally by  flatmap, but also can be used externally)
- */
-export declare class MultiStreamDatasource<T> implements IStreamDataSource<T> {
-    private first;
-    private activeStrm;
-    private selectedPos;
-    private strms;
-    constructor(first: any, ...strms: Array<IStreamDataSource<T>>);
-    current(): any;
-    hasNext(): boolean;
-    private findNextStrm;
-    lookAhead(cnt?: number): T | ITERATION_STATUS;
-    next(): any;
-    reset(): void;
-}
-/**
- * defines a sequence of numbers for our stream input
- */
-export declare class SequenceDataSource implements IStreamDataSource<number> {
-    start: number;
-    total: number;
-    value: number;
-    constructor(start: number, total: number);
-    hasNext(): boolean;
-    next(): number | ITERATION_STATUS;
-    lookAhead(cnt?: number): number | ITERATION_STATUS;
-    reset(): void;
-    current(): number | ITERATION_STATUS;
-}
-/**
- * implementation of a datasource on top of a standard array
- */
-export declare class ArrayStreamDataSource<T> implements IStreamDataSource<T> {
-    value: Array<T>;
-    dataPos: number;
-    constructor(...value: Array<T>);
-    lookAhead(cnt?: number): T | ITERATION_STATUS;
-    hasNext(): boolean;
-    next(): T | ITERATION_STATUS;
-    reset(): void;
-    current(): T;
-}
-/**
- * an intermediate data source which prefilters
- * incoming stream data
- * and lets only the data out which
- * passes the filter function check
- */
-export declare class FilteredStreamDatasource<T> implements IStreamDataSource<T> {
-    filterFunc: (T: any) => boolean;
-    inputDataSource: IStreamDataSource<T>;
-    _current: T | ITERATION_STATUS;
-    _filterIdx: {};
-    _unfilteredPos: number;
-    constructor(filterFunc: (T: any) => boolean, parent: IStreamDataSource<T>);
-    /**
-     * in order to filter we have to make a look ahead until the
-     * first next allowed element
-     * hence we prefetch the element and then
-     * serve it via next
-     */
-    hasNext(): boolean;
-    /**
-     * serve the next element
-     */
-    next(): T | ITERATION_STATUS;
-    /**
-     * looks ahead cnt without changing the internal data "pointers" of the data source
-     * (this is mostly needed by LazyStreams, because they do not know by definition their
-     * boundaries)
-     *
-     * @param cnt the elements to look ahead
-     * @return either the element or ITERATION_STATUS.EO_STRM if we hit the end of the stream before
-     * finding the "cnt" element
-     */
-    lookAhead(cnt?: number): ITERATION_STATUS | T;
-    current(): T | ITERATION_STATUS;
-    reset(): void;
-}
-/**
- * an intermediate datasource which maps the items from
- * one into another
- */
-export declare class MappedStreamDataSource<T, S> implements IStreamDataSource<S> {
-    mapFunc: (T: any) => S;
-    inputDataSource: IStreamDataSource<T>;
-    constructor(mapFunc: (T: any) => S, parent: IStreamDataSource<T>);
-    hasNext(): boolean;
-    next(): S;
-    reset(): void;
-    current(): S;
-    lookAhead(cnt?: number): ITERATION_STATUS | S;
-}
-/**
- * For the time being we only need one collector
- * a collector which collects a stream back into arrays
- */
-export declare class ShimArrayCollector<S> implements ICollector<S, Array<S>> {
-    private data;
-    collect(element: S): void;
-    get finalValue(): Array<S>;
-}
-/**
- * collects the values as inverse array
- */
-export declare class InverseArrayCollector<S> implements ICollector<S, Array<S>> {
-    private data;
-    collect(element: S): void;
-    get finalValue(): Array<S>;
-}
-/**
- * collects an tuple array stream into an assoc array with elements being collected into arrays
- *
- */
-export declare class ArrayAssocArrayCollector<S> implements ICollector<[string, S] | string, {
-    [key: string]: S;
-}> {
-    finalValue: {
-        [key: string]: any;
-    };
-    collect(element: [string, S] | string): void;
-}
-/**
- * dummy collector which just triggers a run
- * on lazy streams without collecting anything
- */
-export declare class Run<S> implements ICollector<S, any> {
-    collect(element: S): void;
-    get finalValue(): any;
-}
-/**
- * collects an assoc stream back to an assoc array
- */
-export declare class AssocArrayCollector<S> implements ICollector<[string, S] | string, {
-    [key: string]: S;
-}> {
-    finalValue: {
-        [key: string]: any;
-    };
-    collect(element: [string, S] | string): void;
-}
-/**
- * A Config collector similar to the FormDFata Collector
- */
-export declare class ConfigCollector implements ICollector<{
-    key: string;
-    value: any;
-}, Config> {
-    finalValue: Config;
-    collect(element: {
-        key: string;
-        value: any;
-    }): void;
-}
-/**
- * Form data collector for key value pair streams
- */
-export declare class FormDataCollector implements ICollector<{
-    key: string;
-    value: any;
-}, FormData> {
-    finalValue: FormData;
-    collect(element: {
-        key: string;
-        value: any;
-    }): void;
-}
-/**
- * Form data collector for DomQuery streams
- */
-export declare class QueryFormDataCollector implements ICollector<DomQuery, FormData> {
-    finalValue: FormData;
-    collect(element: DomQuery): void;
-}
-/**
- * Encoded String collector from dom query streams
- */
-export declare class QueryFormStringCollector implements ICollector<DomQuery, string> {
-    formData: [[string, string]];
-    collect(element: DomQuery): void;
-    get finalValue(): string;
-}
-/**
- * For the time being we only need one collector
- * a collector which collects a stream back into arrays
- */
-export declare class ArrayCollector<S> implements ICollector<S, Array<S>> {
-    private data;
-    collect(element: S): void;
-    get finalValue(): Array<S>;
-}

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

@@ -1,284 +0,0 @@
-/*!
- * 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 { IMonad, IValueHolder, Optional } from "./Monad";
-import { ICollector, IStreamDataSource, ITERATION_STATUS } from "./SourcesCollectors";
-import { DomQuery } from "./DomQuery";
-import { Config } from "./Config";
-export type StreamMapper<T> = (data: T) => IStreamDataSource<any>;
-export type ArrayMapper<T> = (data: T) => Array<any>;
-export type IteratableConsumer<T> = (data: T, pos?: number) => void | boolean;
-export type Reducable<T, V> = (val1: T | V, val2: T) => V;
-export type Matchable<T> = (data: T) => boolean;
-export type Mappable<T, R> = (data: T) => R;
-export type Comparator<T> = (el1: T, el2: T) => number;
-/**
- * Same for flatmap to deal with element -> stream mappings
- */
-export declare class FlatMapStreamDataSource<T, S> implements IStreamDataSource<S> {
-    mapFunc: StreamMapper<T>;
-    inputDataSource: IStreamDataSource<T>;
-    /**
-     * the currently active stream
-     * coming from an incoming element
-     * once the end of this one is reached
-     * it is swapped out by another one
-     * from the next element
-     */
-    activeDataSource: IStreamDataSource<S>;
-    walkedDataSources: any[];
-    _currPos: number;
-    constructor(func: StreamMapper<T>, parent: IStreamDataSource<T>);
-    hasNext(): boolean;
-    private resolveActiveHasNext;
-    lookAhead(cnt?: number): ITERATION_STATUS | S;
-    private toDatasource;
-    private resolveNextHasNext;
-    next(): S | ITERATION_STATUS;
-    reset(): void;
-    current(): S | ITERATION_STATUS;
-}
-/**
- * Generic interface defining a stream
- */
-export interface IStream<T> {
-    /**
-     * Perform the operation fn on a single element in the stream at a time
-     * then pass the stream over for further processing
-     * This is basically an intermediate point in the stream
-     * with further processing happening later, do not use
-     * this method to gather data or iterate over all date for processing
-     * (for the second case each has to be used)
-     *
-     * @param fn the processing function, if it returns false, further processing is stopped
-     */
-    onElem(fn: IteratableConsumer<T>): IStream<T>;
-    /**
-     * Iterate over all elements in the stream and do some processing via fn
-     *
-     * @param fn takes a single element and if it returns false
-     * then further processing is stopped
-     */
-    each(fn: IteratableConsumer<T>): void;
-    /**
-     * maps a single element into another via fn
-     * @param fn function which takes one element in and returns another
-     */
-    map<R>(fn?: Mappable<T, R>): IStream<R>;
-    /**
-     * Takes an element in and returns a set of something
-     * the set then is flatted into a single stream to be further processed
-     *
-     * @param fn
-     */
-    flatMap<R>(fn?: StreamMapper<T> | ArrayMapper<T>): IStream<R>;
-    /**
-     * filtering, takes an element in and is processed by fn.
-     * If it returns false then further processing on this element is skipped
-     * if it returns true it is passed down the chain.
-     *
-     * @param fn
-     */
-    filter(fn?: Matchable<T>): IStream<T>;
-    /**
-     * functional reduce... takes two elements in the stream and reduces to
-     * one from left to right
-     *
-     * @param fn the reduction function for instance (val1,val2) => val1l+val2
-     * @param startVal an optional starting value, if provided the the processing starts with this element
-     * and further goes down into the stream, if not, then the first two elements are taken as reduction starting point
-     */
-    reduce<V>(fn: Reducable<T, V>, startVal: T | V): Optional<T | V>;
-    /**
-     * returns the first element in the stream is given as Optional
-     */
-    first(): Optional<T>;
-    /**
-     * Returns the last stream element (note in endless streams without filtering and limiting you will never reach that
-     * point hence producing an endless loop)
-     */
-    last(): Optional<T>;
-    /**
-     * returns true if there is at least one element where a call fn(element) produces true
-     *
-     * @param fn
-     */
-    anyMatch(fn: Matchable<T>): boolean;
-    /**
-     * returns true if all elmements produce true on a call to fn(element)
-     *
-     * @param fn
-     */
-    allMatch(fn: Matchable<T>): boolean;
-    /**
-     * returns true if no elmements produce true on a call to fn(element)
-     *
-     * @param fn
-     */
-    noneMatch(fn: Matchable<T>): boolean;
-    /**
-     * Collect the elements with a collector given
-     * There are a number of collectors provided
-     *
-     * @param collector
-     */
-    collect(collector: ICollector<T, any>): any;
-    /**
-     * sort on the stream, this is a special case
-     * of an endpoint, so your data which is fed in needs
-     * to be limited otherwise it will fail
-     * it still returns a stream for further processing
-     *
-     * @param comparator
-     */
-    sort(comparator: Comparator<T>): IStream<T>;
-    /**
-     * Limits the stream to a certain number of elements
-     *
-     * @param end the limit of the stream
-     */
-    limits(end: number): IStream<T>;
-    concat(...toAppend: Array<IStream<T>>): IStream<T>;
-    /**
-     * returns the stream collected into an array (90% use-case abbreviation
-     */
-    value: Array<T>;
-    /**
-     * returns the currently element selected in the stream
-     */
-    current(): T | ITERATION_STATUS;
-    /**
-     * returns an observable of the given stream
-     */
-    [Symbol.iterator](): Iterator<T>;
-}
-/**
- * A simple typescript based reimplementation of streams
- *
- * This is the early eval version
- * for a lazy eval version check, LazyStream, which is api compatible
- * to this implementation, however with the benefit of being able
- * to provide infinite data sources and generic data providers, the downside
- * is, it might be a tad slower in some situations
- */
-export declare class Stream<T> implements IMonad<T, Stream<any>>, IValueHolder<Array<T>>, IStream<T>, IStreamDataSource<T> {
-    value: Array<T>;
-    _limits: number;
-    private pos;
-    constructor(...value: T[]);
-    static of<T>(...data: Array<T>): Stream<T>;
-    static ofAssoc<T>(data: {
-        [key: string]: T;
-    }): Stream<[string, T]>;
-    static ofDataSource<T>(dataSource: IStreamDataSource<T>): Stream<T>;
-    static ofDomQuery(value: DomQuery): Stream<DomQuery>;
-    static ofConfig(value: Config): Stream<[string, any]>;
-    current(): T | ITERATION_STATUS;
-    limits(end: number): Stream<T>;
-    /**
-     * concat for streams, so that you can concat two streams together
-     * @param toAppend
-     */
-    concat(...toAppend: Array<IStream<T>>): Stream<T>;
-    onElem(fn: (data: T, pos?: number) => void | boolean): Stream<T>;
-    each(fn: (data: T, pos?: number) => void | boolean): void;
-    map<R>(fn?: (data: T) => R): Stream<R>;
-    flatMap<IStreamDataSource>(fn: (data: T) => IStreamDataSource | Array<any>): Stream<any>;
-    filter(fn?: (data: T) => boolean): Stream<T>;
-    reduce<V>(fn: Reducable<T, V | T>, startVal?: V): Optional<V | T>;
-    first(): Optional<T>;
-    last(): Optional<T>;
-    anyMatch(fn: Matchable<T>): boolean;
-    allMatch(fn: Matchable<T>): boolean;
-    noneMatch(fn: Matchable<T>): boolean;
-    sort(comparator: Comparator<T>): IStream<T>;
-    collect(collector: ICollector<T, any>): any;
-    hasNext(): boolean;
-    next(): T;
-    lookAhead(cnt?: number): T | ITERATION_STATUS;
-    [Symbol.iterator](): Iterator<T>;
-    reset(): void;
-}
-/**
- * Lazy implementation of a Stream
- * The idea is to connect the intermediate
- * streams as datasources like a linked list
- * with reverse referencing and for special
- * operations like filtering flatmapping
- * have intermediate datasources in the list
- * with specialized functions.
- *
- * Sort of a modified pipe valve pattern
- * the streams are the pipes the intermediate
- * data sources are the valves
- *
- * We then can use passed in functions to control
- * the flow in the valves
- *
- * That way we can have a lazy evaluating stream
- *
- * So if an endpoint requests data
- * a callback trace goes back the stream list
- * which triggers an operation upwards
- * which sends data down the drain which then is processed
- * and filtered until one element hits the endpoint.
- *
- * That is repeated, until all elements are processed
- * or an internal limit is hit.
- *
- */
-export declare class LazyStream<T> implements IStreamDataSource<T>, IStream<T>, IMonad<T, LazyStream<any>> {
-    protected dataSource: IStreamDataSource<T>;
-    _limits: number;
-    pos: number;
-    static of<T>(...values: Array<T>): LazyStream<T>;
-    static ofAssoc<T>(data: {
-        [key: string]: T;
-    }): LazyStream<[string, T]>;
-    static ofStreamDataSource<T>(value: IStreamDataSource<T>): LazyStream<T>;
-    static ofDomQuery(value: DomQuery): LazyStream<DomQuery>;
-    static ofConfig(value: Config): LazyStream<[string, any]>;
-    constructor(parent: IStreamDataSource<T>);
-    hasNext(): boolean;
-    next(): T | ITERATION_STATUS;
-    lookAhead(cnt?: number): ITERATION_STATUS | T;
-    current(): T | ITERATION_STATUS;
-    reset(): void;
-    /**
-     * concat for streams, so that you can concat two streams together
-     * @param toAppend
-     */
-    concat(...toAppend: Array<IStream<T>>): LazyStream<T>;
-    nextFilter(fn: Matchable<T>): T;
-    limits(max: number): LazyStream<T>;
-    collect(collector: ICollector<T, any>): any;
-    onElem(fn: IteratableConsumer<T>): LazyStream<T>;
-    filter(fn: Matchable<T>): LazyStream<T>;
-    map<R>(fn: Mappable<T, R>): LazyStream<any>;
-    flatMap<StreamMapper>(fn: StreamMapper | ArrayMapper<any>): LazyStream<any>;
-    each(fn: IteratableConsumer<T>): void;
-    reduce<V>(fn: Reducable<T, V>, startVal?: T | V): Optional<T | V>;
-    last(): Optional<T>;
-    first(): Optional<T>;
-    anyMatch(fn: Matchable<T>): boolean;
-    allMatch(fn: Matchable<T>): boolean;
-    noneMatch(fn: Matchable<T>): boolean;
-    sort(comparator: Comparator<T>): IStream<T>;
-    get value(): Array<T>;
-    [Symbol.iterator](): Iterator<T>;
-    private stop;
-    private isOverLimits;
-}

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

@@ -1,50 +0,0 @@
-/*!
- * 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.
- */
-/**
- * beginning custom tag support
- *
- * This api is still experimental
- * and might be interwoven with DomQuery
- * so it is bound to change
- *
- * it follows a builder pattern to allow easier creations
- * with less code of custom tags
- */
-export declare class TagBuilder {
-    tagName: string;
-    connectedCallback?: Function;
-    clazz?: CustomElementConstructor;
-    extendsType: CustomElementConstructor;
-    theOptions: ElementDefinitionOptions | null;
-    markup: string;
-    disconnectedCallback?: Function;
-    adoptedCallback?: Function;
-    attributeChangedCallback?: Function;
-    observedAttrs: string[];
-    static withTagName(tagName: any): TagBuilder;
-    constructor(tagName: string);
-    withObservedAttributes(...oAttrs: any[]): void;
-    withConnectedCallback(callback: Function): this;
-    withDisconnectedCallback(callback: Function): this;
-    withAdoptedCallback(callback: Function): this;
-    withAttributeChangedCallback(callback: Function): this;
-    withExtendsType(extendsType: CustomElementConstructor): this;
-    withOptions(theOptions: any): this;
-    withClass(clazz: any): this;
-    withMarkup(markup: any): this;
-    register(): void;
-}

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

@@ -1,31 +0,0 @@
-/*!
- * 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 } from "./DomQuery";
-/**
- * xml query as specialized case for DomQuery
- */
-export declare class XMLQuery extends DomQuery {
-    constructor(rootNode: Document | string | DomQuery, docType?: string);
-    isXMLParserError(): boolean;
-    toString(): string;
-    parserErrorText(joinstr: string): string;
-    static parseXML(txt: string): XMLQuery;
-    static parseHTML(txt: string): XMLQuery;
-    static fromString(txt: string, parseType?: string): XMLQuery;
-}
-export declare const XQ: typeof XMLQuery;
-export type XQ = XMLQuery;