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

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

@@ -1,480 +0,0 @@
-import { Optional, ValueEmbedder } from "./Monad";
-import { XMLQuery } from "./XmlQuery";
-import { DomQuery, ElementAttribute, Style, WAIT_OPTS } from "./DomQuery";
-export interface IDomQuery {
-    /**
-     * reference to the systems global object
-     * (globalThis, window, global, depending on the environment)
-     */
-    readonly global: any;
-    /**
-     * reads the first element if it exists and returns an optional
-     */
-    readonly value: Optional<Element>;
-    /**
-     * All elements as array
-     */
-    readonly values: Element[];
-    /**
-     * returns the id as settable value (See also ValueEmbedder)
-     */
-    readonly id: ValueEmbedder<string>;
-    /**
-     * returns the length of embedded nodes (top level)
-     */
-    readonly length: number;
-    /**
-     * the tag name of the first element
-     */
-    readonly tagName: Optional<string>;
-    /**
-     * the node name of the first element
-     */
-    readonly nodeName: Optional<string>;
-    /**
-     * the type of the first element
-     */
-    readonly type: Optional<string>;
-    /**
-     * The name as changeable value
-     */
-    readonly name: ValueEmbedder<string>;
-    /**
-     * The value in case of inputs as changeable value
-     */
-    readonly inputValue: ValueEmbedder<string | boolean>;
-    /**
-     * accumulated top element offsetWidth
-     */
-    readonly offsetWidth: number;
-    /**
-     * accumulated top element offsetHeight
-     */
-    readonly offsetHeight: number;
-    /**
-     * accumulated top element offsetLeft
-     */
-    readonly offsetLeft: number;
-    /**
-     * accumulated top element offsetTop
-     */
-    readonly offsetTop: number;
-    /**
-     * abbreviation for inputValue\.value to make
-     * the code terser
-     */
-    val: string | boolean;
-    /**
-     * the underlying form elements as DomQuery object
-     */
-    readonly elements: DomQuery;
-    /**
-     * settable flag for disabled
-     */
-    disabled: boolean;
-    /**
-     * The child nodes of this node collection as readonly attribute
-     */
-    readonly childNodes: DomQuery;
-    /**
-     * an early stream representation for this DomQuery
-     */
-    readonly stream: any;
-    /**
-     * lazy stream representation for this DomQuery
-     */
-    readonly lazyStream: any;
-    /**
-     * transform this node collection to an array
-     */
-    readonly asArray: Array<DomQuery>;
-    /**
-     * inner html property
-     * setter and getter which works directly on strings
-     */
-    innerHTML: string;
-    /**
-     * same as innerHTML
-     * will be removed once
-     * my code is transitioned
-     * @deprecated do not use anymore, user innerHTML instead
-     */
-    innerHtml: string;
-    /**
-     * convenience for dq.id.value to make the code a little tighter
-     */
-    nodeId: string;
-    /**
-     * returns true if the elements have the tag *tagName* as tag embedded ( highest level )
-     * @param tagName
-     */
-    isTag(tagName: string): boolean;
-    /**
-     * returns the nth element as DomQuery
-     * from the internal elements
-     * note if you try to reach a non-existing element position
-     * you will get back an absent entry
-     *
-     * @param index the nth index
-     */
-    get(index: number): DomQuery;
-    /**
-     * returns the nth element as optional of an Element object
-     * @param index the number from the index
-     * @param defaults the default value if the index is overrun default Optional\.absent
-     */
-    getAsElem(index: number, defaults: Optional<any>): Optional<Element>;
-    /**
-     * returns the value array< of all elements
-     */
-    allElems(): Array<Element>;
-    /**
-     * absent no values reached?
-     */
-    isAbsent(): boolean;
-    /**
-     * should make the code clearer
-     * note if you pass a function
-     * this refers to the active DomQuery object
-     */
-    isPresent(presentRunnable?: (elem?: DomQuery) => void): boolean;
-    /**
-     * should make the code clearer
-     * note if you pass a function
-     * this refers to the active DomQuery object
-     *
-     *
-     * @param presentRunnable
-     */
-    ifPresentLazy(presentRunnable: (elem?: DomQuery) => void): DomQuery;
-    /**
-     * remove all affected nodes from this query object from the dom tree
-     */
-    delete(): void;
-    /**
-     * query selector all on the existing dom query object
-     *
-     * @param selector the standard selector
-     * @return a DomQuery with the results
-     */
-    querySelectorAll(selector: any): DomQuery;
-    /**
-     * closest, walks up the dom tree to fid the closest element to match
-     *
-     * @param selector the standard selector
-     * @return a DomQuery with the results
-     */
-    querySelectorAll(selector: any): DomQuery;
-    /**
-     * core byId method
-     * @param id the id to search for
-     * @param includeRoot also match the root element?
-     */
-    byId(id: string, includeRoot?: boolean): DomQuery;
-    /**
-     * same as byId just for the tag name
-     * @param tagName
-     * @param includeRoot
-     */
-    byTagName(tagName: string, includeRoot?: boolean): DomQuery;
-    /**
-     * attr accessor, usage myQuery.attr("class").value = "bla"
-     * or let value myQuery.attr("class").value
-     * @param attr the attribute to set
-     * @param defaultValue the default value in case nothing is presented (defaults to null)
-     */
-    attr(attr: string, defaultValue: string): ElementAttribute;
-    /**
-     * style accessor
-     * @param defaultValue the default value in case nothing is presented (defaults to null)
-     * @param cssProperty
-     */
-    style(cssProperty: string, defaultValue: string): Style;
-    /**
-     * Checks for an existing class in the class attributes
-     *
-     * @param clazz the class to search for
-     */
-    hasClass(clazz: string): boolean;
-    /**
-     * appends a class string if not already in the element(s)
-     *
-     * @param clazz the style class to append
-     */
-    addClass(clazz: string): DomQuery;
-    /**
-     * remove the style class if in the class definitions
-     *
-     * @param clazz
-     */
-    removeClass(clazz: string): DomQuery;
-    /**
-     * checks whether we have a multipart element in our children
-     */
-    isMultipartCandidate(): boolean;
-    /**
-     * innerHtml
-     * equivalent to jQueries html
-     * as setter the html is set and the
-     * DomQuery is given back
-     * as getter the html string is returned
-     *
-     * @param newInnerHTML
-     */
-    html(newInnerHTML?: string): DomQuery | Optional<string>;
-    /**
-     * dispatch event on all children
-     * just a delegated dispatchEvent from the standard
-     * dom working on all queried elements in the monad level
-     *
-     * @param evt the event to be dispatched
-     */
-    dispatchEvent(evt: Event): DomQuery;
-    /**
-     * easy node traversal, you can pass
-     * a set of node selectors which are joined as direct children
-     *
-     * Note! The root nodes are not in the getIf, those are always the child nodes
-     *
-     * @param nodeSelector
-     */
-    getIf(...nodeSelector: Array<string>): DomQuery;
-    /**
-     * iterate over each element and perform something on the element
-     * (Dom element is passed instead of DomQuery)
-     * @param func
-     */
-    eachElem(func: (item: Element, cnt?: number) => any): DomQuery;
-    /**
-     * perform an operation on the first element
-     * returns a DomQuery on the first element only
-     * @param func
-     */
-    firstElem(func: (item: Element, cnt?: number) => any): DomQuery;
-    /**
-     * perform an operation on the first element
-     * returns a DomQuery on the first element only
-     * @param func
-     */
-    lastElem(func: (item: Element, cnt?: number) => any): DomQuery;
-    /**
-     * same as eachElem, but a DomQuery object is passed down
-     *
-     * @param func
-     */
-    each(func: (item: DomQuery, cnt?: number) => any): DomQuery;
-    /**
-     * returns a new dom query containing only the first element max
-     *
-     * @param func a an optional callback function to perform an operation on the first element
-     */
-    first(func: (item: DomQuery, cnt?: number) => any): DomQuery;
-    /**
-     * returns a new dom query containing only the first element max
-     *
-     * @param func a an optional callback function to perform an operation on the first element
-     */
-    last(func: (item: DomQuery, cnt?: number) => any): DomQuery;
-    /**
-     * filter function which filters a subset
-     *
-     * @param func
-     */
-    filter(func: (item: DomQuery) => boolean): DomQuery;
-    /**
-     * global eval head appendix method
-     * no other methods are supported anymore
-     * @param code the code to be evaluated
-     * @param  nonce optional  nonce key for higher security
-     */
-    globalEval(code: string, nonce?: string): DomQuery;
-    /**
-     * Runs an eval and keeps the evaluated code in the head
-     * This is a corner condition, where we want to update the head with custom
-     * code and leave the code in (instead of deleting ig)
-     *
-     * @param code the code to be evaluated
-     * @param  nonce optional  nonce key for higher security
-     */
-    globalEvalSticky(code: string, nonce?: string): DomQuery;
-    /**
-     * detaches a set of nodes from their parent elements
-     * in a browser independent manner
-     * @return {DomQuery} DomQuery of nodes with the detached dom nodes
-     */
-    detach(): DomQuery;
-    /**
-     * appends the current set of elements
-     * to the element or first element passed via elem
-     * @param elem
-     */
-    appendTo(elem: DomQuery | string): DomQuery;
-    /**
-     * appends the passed elements to our existing queries
-     * note, double appends can happen if you are not careful
-     *
-     * @param elem to append
-     */
-    append(elem: DomQuery): DomQuery;
-    /**
-     * replace convenience function replaces the domquery elements with the
-     * elements passed as parameter
-     * @param toReplace the replacement elements
-     * @return a reference on the replacement elements
-     */
-    replace(toReplace: DomQuery): DomQuery;
-    /**
-     * appends the passed elements to our existing queries
-     * note, double appends can happen if you are not careful
-     *
-     * @param elem to append
-     */
-    prepend(elem: DomQuery): DomQuery;
-    /**
-     * prepend equivalent to appendTo
-     *
-     * @param elem the element to prepend to
-     */
-    prependTo(elem: DomQuery): DomQuery;
-    /**
-     * loads and evaluates a script from a source uri
-     *
-     * @param src the source to be loaded and evaluated
-     * @param delay in milliseconds execution default (0 == no delay)
-     * @param charSet
-     */
-    loadScriptEval(src: string, delay: number, charSet: string): void;
-    /**
-     * insert toInsert after the current element
-     *
-     * @param toInsert an array of DomQuery objects
-     */
-    insertAfter(...toInsert: Array<DomQuery>): DomQuery;
-    /**
-     * inserts the elements before the current element
-     *
-     * @param toInsert
-     */
-    insertBefore(...toInsert: Array<DomQuery>): DomQuery;
-    /**
-     * in case the DomQuery is pointing to nothing the else value is taken into consideration
-     * als alternative
-     *
-     * @param elseValue the else value
-     */
-    orElse(...elseValue: any): DomQuery;
-    /**
-     * the same with lazy evaluation for cases where getting the else value
-     * is a heavy operation
-     *
-     * @param func the else provider function
-     */
-    orElseLazy(func: () => any): DomQuery;
-    /**
-     * find all parents in the hierarchy for which the selector matches
-     * @param selector
-     */
-    allParents(selector: string): DomQuery;
-    /**
-     * first parents with a matching selector
-     * @param selector
-     */
-    firstParent(selector: string): DomQuery;
-    /**
-     * all parents until the selector match stops
-     * @param selector
-     */
-    parentsWhileMatch(selector: string): DomQuery;
-    /**
-     * the parent of the elements
-     */
-    parent(): DomQuery;
-    /**
-     * copy all attributes of sourceItem to this DomQuery items
-     *
-     * @param sourceItem the source item to copy over (can be another DomQuery or a parsed XML Query item)
-     */
-    copyAttrs(sourceItem: DomQuery | XMLQuery): DomQuery;
-    /**
-     * outerHTML convenience method
-     * browsers only support innerHTML but
-     * for instance for your jsf.js we have a full
-     * replace pattern which needs outerHTML processing
-     *
-     * @param markup
-     * @param runEmbeddedScripts
-     * @param runEmbeddedCss
-     */
-    outerHTML(markup: string, runEmbeddedScripts?: boolean, runEmbeddedCss?: boolean): DomQuery;
-    /**
-     * Run through the given nodes in the DomQuery execute the inline scripts
-     * @param sticky if set to true the element must be left in the head after eval default === false
-     * @param whiteListed: optional whitelist function which can filter out script tags which are not processed
-     * defaults to the standard jsf.js exclusion (we use this code for myfaces)
-     */
-    runScripts(sticky?: boolean, whiteListed?: (val: string) => boolean): DomQuery;
-    /**
-     * runs the embedded css
-     */
-    runCss(): DomQuery;
-    /**
-     * fires a click event on the underlying dom elements
-     */
-    click(): DomQuery;
-    /**
-     * adds an event listener
-     *
-     * @param type
-     * @param listener
-     * @param options
-     */
-    addEventListener(type: string, listener: (evt: Event) => void, options?: boolean | EventListenerOptions): DomQuery;
-    /**
-     * removes an event listener
-     *
-     * @param type
-     * @param listener
-     * @param options
-     */
-    removeEventListener(type: string, listener: (evt: Event) => void, options?: boolean | EventListenerOptions): DomQuery;
-    /**
-     * fires an event
-     */
-    fireEvent(eventName: string): void;
-    textContent(joinString?: string): string;
-    innerText(joinString?: string): string;
-    /**
-     * encodes all input elements properly into respective
-     * config entries, this can be used
-     * for legacy systems, for newer use-cases, use the
-     * HTML5 Form class which all newer browsers provide
-     *
-     * @param toMerge optional config which can be merged in
-     * @return a copy pf
-     */
-    encodeFormElement(toMerge: any): {
-        [key: string]: any;
-    };
-    /**
-     * fetches the sub-nodes from ... to..
-     * @param from
-     * @param to
-     */
-    subNodes(from: number, to?: number): DomQuery;
-    /**
-     * attach shadow elements
-     * 1:1 mapping from attach shadow
-     *
-     * @param modeParams
-     */
-    attachShadow(modeParams: {
-        [key: string]: string;
-    }): DomQuery;
-    /**
-     * wait until a condition on the dom is reached
-     *
-     * @return a promise on the affected elements where the condition
-     * @throws an error in case of a timeout
-     */
-    waitUntilDom(condition: (element: DomQuery) => boolean, options: WAIT_OPTS): Promise<DomQuery>;
-}

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

@@ -1,97 +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 { Optional } from "./Monad";
-/**
- * Lang helpers crossported from the apache myfaces project
- */
-export declare module Lang {
-    /**
-     * helper function to safely resolve anything
-     * this is not an elvis operator, it resolves
-     * a value without exception in a tree and if
-     * it is not resolvable then an optional of
-     * a default value is restored or Optional.empty
-     * if none is given
-     *
-     * usage
-     * <code>
-     *     let var: Optiona<string> = saveResolve(() => a.b.c.d.e, "foobaz")
-     * </code>
-     *
-     * @param resolverProducer a lambda which can produce the value
-     * @param defaultValue an optional default value if the producer failes to produce anything
-     * @returns an Optional of the produced value
-     */
-    function saveResolve<T>(resolverProducer: () => T, defaultValue?: T): Optional<T>;
-    /**
-     * lazy resolve... aka the function is called on resolve and a default value also
-     * is a producing function (called only if the original producer does not produce any result)
-     * @param resolverProducer the producer for the resolve
-     * @param defaultValue the default value producer function
-     */
-    function saveResolveLazy<T>(resolverProducer: () => T, defaultValue?: () => T): Optional<T>;
-    /**
-     * String to array function performs a string to array transformation
-     * @param {String} it the string which has to be changed into an array
-     * @param {RegExp} splitter our splitter reglar expression
-     * @return a trimmed array of the splitted string
-     */
-    function strToArray(it: string, splitter?: string | RegExp): Array<string>;
-    /**
-     * hyperfast trim
-     * http://blog.stevenlevithan.com/archives/faster-trim-javascript
-     * crossported from dojo
-     */
-    function trim(str: string): string;
-    /**
-     * generic object arrays like dom definitions to array conversion method which
-     * transforms any object to something array like
-     * @param obj
-     * @param offset
-     * @param pack
-     * @returns an array converted from the object
-     */
-    function objToArray<T>(obj: any, offset?: number, pack?: Array<T>): Array<T>;
-    /**
-     * equalsIgnoreCase, case-insensitive comparison of two strings
-     *
-     * @param source
-     * @param destination
-     */
-    function equalsIgnoreCase(source?: string, destination?: string): boolean;
-    /**
-     * runtime type assertion
-     *
-     * @param probe the probe to be tested for a type
-     * @param theType the type to be tested for
-     */
-    function assertType(probe: any, theType: any): boolean;
-    /**
-     * Back ported from Dojo
-     * a failsafe string determination method
-     * (since in javascript String != "" typeof alone fails!)
-     * @param it {|Object|} the object to be checked for being a string
-     * @return true in case of being a string false otherwise
-     */
-    function isString(it?: any): boolean;
-    /**
-     * Back-ported, a failsafe determination code for checking whether an object is a function
-     * @param it the object to check for being a function
-     */
-    function isFunc(it: any): boolean;
-    function objAssign(target: any, ...theArgs: any): any;
-}