@bloomreach/react-banana-ui 1.1.0-next.1

package/dist/utils/normalize-wheel/UserAgent_DEPRECATED.d.ts

@@ -0,0 +1,116 @@
+/**
+  BSD License
+
+  Copyright (c) 2015, Facebook, Inc. All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without modification,
+  are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the name Facebook nor the names of its contributors may be used to
+    endorse or promote products derived from this software without specific
+    prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+  ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+declare var UserAgent_DEPRECATED: {
+    /**
+     *  Check if the UA is Internet Explorer.
+     *
+     *
+     *  @return float|NaN Version number (if match) or NaN.
+     */
+    ie: () => any;
+    /**
+     * Check if we're in Internet Explorer compatibility mode.
+     *
+     * @return bool true if in compatibility mode, false if
+     * not compatibility mode or not ie
+     */
+    ieCompatibilityMode: () => any;
+    /**
+     * Whether the browser is 64-bit IE.  Really, this is kind of weak sauce;  we
+     * only need this because Skype can't handle 64-bit IE yet.  We need to remove
+     * this when we don't need it -- tracked by #601957.
+     */
+    ie64: () => any;
+    /**
+     *  Check if the UA is Firefox.
+     *
+     *
+     *  @return float|NaN Version number (if match) or NaN.
+     */
+    firefox: () => any;
+    /**
+     *  Check if the UA is Opera.
+     *
+     *
+     *  @return float|NaN Version number (if match) or NaN.
+     */
+    opera: () => any;
+    /**
+     *  Check if the UA is WebKit.
+     *
+     *
+     *  @return float|NaN Version number (if match) or NaN.
+     */
+    webkit: () => any;
+    /**
+     *  For Push
+     *  WILL BE REMOVED VERY SOON. Use UserAgent_DEPRECATED.webkit
+     */
+    safari: () => any;
+    /**
+     *  Check if the UA is a Chrome browser.
+     *
+     *
+     *  @return float|NaN Version number (if match) or NaN.
+     */
+    chrome: () => any;
+    /**
+     *  Check if the user is running Windows.
+     *
+     *  @return bool `true' if the user's OS is Windows.
+     */
+    windows: () => any;
+    /**
+     *  Check if the user is running Mac OS X.
+     *
+     *  @return float|bool   Returns a float if a version number is detected,
+     *                       otherwise true/false.
+     */
+    osx: () => any;
+    /**
+     * Check if the user is running Linux.
+     *
+     * @return bool `true' if the user's OS is some flavor of Linux.
+     */
+    linux: () => any;
+    /**
+     * Check if the user is running on an iPhone or iPod platform.
+     *
+     * @return bool `true' if the user is running some flavor of the
+     *    iPhone OS.
+     */
+    iphone: () => any;
+    mobile: () => any;
+    nativeApp: () => any;
+    android: () => any;
+    ipad: () => any;
+};
+export default UserAgent_DEPRECATED;

package/dist/utils/normalize-wheel/index.d.ts

@@ -0,0 +1,2 @@
+import { normalizeWheel } from './normalizeWheel';
+export { normalizeWheel };

package/dist/utils/normalize-wheel/isEventSupported.d.ts

@@ -0,0 +1,46 @@
+/**
+  BSD License
+
+  Copyright (c) 2015, Facebook, Inc. All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without modification,
+  are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the name Facebook nor the names of its contributors may be used to
+    endorse or promote products derived from this software without specific
+    prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+  ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+/**
+ * Checks if an event is supported in the current execution environment.
+ *
+ * NOTE: This will not work correctly for non-generic events such as `change`,
+ * `reset`, `load`, `error`, and `select`.
+ *
+ * Borrows from Modernizr.
+ *
+ * @param {string} eventNameSuffix Event name, e.g. "click".
+ * @param {?boolean} capture Check if the capture phase is supported.
+ * @return {boolean} True if the event is supported.
+ * @internal
+ * @license Modernizr 3.0.0pre (Custom Build) | MIT
+ */
+declare function isEventSupported(eventNameSuffix: any, capture?: any): boolean;
+export default isEventSupported;

package/dist/utils/normalize-wheel/normalizeWheel.d.ts

@@ -0,0 +1,139 @@
+/**
+  BSD License
+
+  Copyright (c) 2015, Facebook, Inc. All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without modification,
+  are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the name Facebook nor the names of its contributors may be used to
+    endorse or promote products derived from this software without specific
+    prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+  ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+/**
+ * Mouse wheel (and 2-finger trackpad) support on the web sucks.  It is
+ * complicated, thus this doc is long and (hopefully) detailed enough to answer
+ * your questions.
+ *
+ * If you need to react to the mouse wheel in a predictable way, this code is
+ * like your bestest friend. * hugs *
+ *
+ * As of today, there are 4 DOM event types you can listen to:
+ *
+ *   'wheel'                -- Chrome(31+), FF(17+), IE(9+)
+ *   'mousewheel'           -- Chrome, IE(6+), Opera, Safari
+ *   'MozMousePixelScroll'  -- FF(3.5 only!) (2010-2013) -- don't bother!
+ *   'DOMMouseScroll'       -- FF(0.9.7+) since 2003
+ *
+ * So what to do?  The is the best:
+ *
+ *   normalizeWheel.getEventType();
+ *
+ * In your event callback, use this code to get sane interpretation of the
+ * deltas.  This code will return an object with properties:
+ *
+ *   spinX   -- normalized spin speed (use for zoom) - x plane
+ *   spinY   -- " - y plane
+ *   pixelX  -- normalized distance (to pixels) - x plane
+ *   pixelY  -- " - y plane
+ *
+ * Wheel values are provided by the browser assuming you are using the wheel to
+ * scroll a web page by a number of lines or pixels (or pages).  Values can vary
+ * significantly on different platforms and browsers, forgetting that you can
+ * scroll at different speeds.  Some devices (like trackpads) emit more events
+ * at smaller increments with fine granularity, and some emit massive jumps with
+ * linear speed or acceleration.
+ *
+ * This code does its best to normalize the deltas for you:
+ *
+ *   - spin is trying to normalize how far the wheel was spun (or trackpad
+ *     dragged).  This is super useful for zoom support where you want to
+ *     throw away the chunky scroll steps on the PC and make those equal to
+ *     the slow and smooth tiny steps on the Mac. Key data: This code tries to
+ *     resolve a single slow step on a wheel to 1.
+ *
+ *   - pixel is normalizing the desired scroll delta in pixel units.  You'll
+ *     get the crazy differences between browsers, but at least it'll be in
+ *     pixels!
+ *
+ *   - positive value indicates scrolling DOWN/RIGHT, negative UP/LEFT.  This
+ *     should translate to positive value zooming IN, negative zooming OUT.
+ *     This matches the newer 'wheel' event.
+ *
+ * Why are there spinX, spinY (or pixels)?
+ *
+ *   - spinX is a 2-finger side drag on the trackpad, and a shift + wheel turn
+ *     with a mouse.  It results in side-scrolling in the browser by default.
+ *
+ *   - spinY is what you expect -- it's the classic axis of a mouse wheel.
+ *
+ *   - I dropped spinZ/pixelZ.  It is supported by the DOM 3 'wheel' event and
+ *     probably is by browsers in conjunction with fancy 3D controllers .. but
+ *     you know.
+ *
+ * Implementation info:
+ *
+ * Examples of 'wheel' event if you scroll slowly (down) by one step with an
+ * average mouse:
+ *
+ *   OS X + Chrome  (mouse)     -    4   pixel delta  (wheelDelta -120)
+ *   OS X + Safari  (mouse)     -  N/A   pixel delta  (wheelDelta  -12)
+ *   OS X + Firefox (mouse)     -    0.1 line  delta  (wheelDelta  N/A)
+ *   Win8 + Chrome  (mouse)     -  100   pixel delta  (wheelDelta -120)
+ *   Win8 + Firefox (mouse)     -    3   line  delta  (wheelDelta -120)
+ *
+ * On the trackpad:
+ *
+ *   OS X + Chrome  (trackpad)  -    2   pixel delta  (wheelDelta   -6)
+ *   OS X + Firefox (trackpad)  -    1   pixel delta  (wheelDelta  N/A)
+ *
+ * On other/older browsers.. it's more complicated as there can be multiple and
+ * also missing delta values.
+ *
+ * The 'wheel' event is more standard:
+ *
+ * http://www.w3.org/TR/DOM-Level-3-Events/#events-wheelevents
+ *
+ * The basics is that it includes a unit, deltaMode (pixels, lines, pages), and
+ * deltaX, deltaY and deltaZ.  Some browsers provide other values to maintain
+ * backward compatibility with older events.  Those other values help us
+ * better normalize spin speed.  Example of what the browsers provide:
+ *
+ *                          | event.wheelDelta | event.detail
+ *        ------------------+------------------+--------------
+ *          Safari v5/OS X  |       -120       |       0
+ *          Safari v5/Win7  |       -120       |       0
+ *         Chrome v17/OS X  |       -120       |       0
+ *         Chrome v17/Win7  |       -120       |       0
+ *                IE9/Win7  |       -120       |   undefined
+ *         Firefox v4/OS X  |     undefined    |       1
+ *         Firefox v4/Win7  |     undefined    |       3
+ *
+ */
+export declare function normalizeWheel(/* object*/ event: any): {
+    spinX: number;
+    spinY: number;
+    pixelX: number;
+    pixelY: number;
+};
+export declare namespace normalizeWheel {
+    var getEventType: () => "wheel" | "DOMMouseScroll" | "mousewheel";
+}

package/dist/utils/promise-resolver.d.ts

@@ -0,0 +1,36 @@
+export interface IPromiseResolver<T> {
+    /**
+     * When set, immediately resolves this resolver with the provided value.
+     */
+    resolveValue?: T;
+}
+/**
+ * This is a convenience object for creating a promise and retrieving it's resolve method for
+ * later use in resolving a situation. Very handy for making a method asynchronous.
+ */
+export declare class PromiseResolver<T> {
+    private resolver;
+    private rejector;
+    promise: Promise<T>;
+    /**
+     * This resolver can supersede other resolvers and hijack their ability to
+     * resolve until this resolver resolves. There is also the ability to make
+     * this resolver wait for all the child resolvers to wait before any of the
+     * resolvers can continue. These children represent the resolvers this
+     * resolver hijacked.
+     */
+    children?: PromiseResolver<any>[];
+    /** Stores the resolution values of each child that gets resolved */
+    private childResolutions?;
+    private childResolvers?;
+    constructor(options?: IPromiseResolver<T>);
+    resolve(val: T): void;
+    reject<U>(reason: U): void;
+    /**
+     * This causes this resolver to steal the child resolver's resolve method and
+     * force the child to wait for this resolver to complete. This is similar to a
+     * cancellation pattern EXCEPT it instead continues execution for all
+     * processes waiting for a common task resolution.
+     */
+    hijack(child: PromiseResolver<any>): void;
+}

package/dist/utils/relative-client-rect.d.ts

@@ -0,0 +1,5 @@
+import { DOMRectBounds, DOMRectPadding } from './clone-client-rect';
+/**
+ * Calculates a ClientRect that is relative to another client rect.
+ */
+export declare function relativeClientRect(source?: DOMRectBounds, relativeTo?: DOMRectBounds, padding?: DOMRectPadding): DOMRectBounds;

package/dist/utils/rush.d.ts

@@ -0,0 +1,4 @@
+/**
+ * This forces a flow to completion with the final yield value returned.
+ */
+export declare function rush<T>(generator: Iterable<T>): Promise<any>;

package/dist/utils/state-controls.d.ts

@@ -0,0 +1,28 @@
+import * as React from 'react';
+interface IHoverState {
+    hovered: boolean;
+}
+interface IFocusState {
+    focused: boolean;
+}
+interface IMosueDownState {
+    mousedown: boolean;
+}
+export declare function controlHover<TState extends IHoverState>(component: React.Component<any, TState> & {
+    container?: React.RefObject<HTMLDivElement>;
+}, over?: (e: React.MouseEvent) => void | boolean, out?: (e: React.MouseEvent) => void | boolean): {
+    onMouseOver: (e: React.MouseEvent) => void;
+    onMouseLeave: (e: React.MouseEvent) => void;
+};
+export declare function controlMouseDown<TState extends IMosueDownState>(component: React.Component<any, TState> & {
+    container?: React.RefObject<HTMLDivElement>;
+}): {
+    onMouseDown: () => void;
+    onMouseUp: () => void;
+    onMouseOut: (e: React.MouseEvent) => void;
+};
+export declare function controlFocus<TState extends IFocusState>(component: React.Component<any, TState>): {
+    onFocus: () => void;
+    onBlur: () => void;
+};
+export {};

package/dist/utils/stop-all-propagation.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+/**
+ * This is a VERY thorough event propogation halt. This prevents defaults
+ * and propogation and handles native and React events.
+ */
+export declare function stopPropagation(e: React.MouseEvent | React.ChangeEvent | (MouseEvent & {
+    nativeEvent?: any;
+}) | Event): boolean;

package/dist/utils/template.d.ts

@@ -0,0 +1,49 @@
+export interface ITemplateResults {
+    /** This is the resulting template string generated from the templating */
+    template: string;
+    /** This is the template options provided by the template. {option: num occurrences} */
+    templateProvidedOptions: Map<string, number>;
+    /**
+     * This is the template options provided by the template that were not resolved by the options parameter
+     * {option: num occurrences}
+     */
+    unresolvedTemplateOptions: Map<string, number>;
+    /** This is the options provided to the template that did not get resolved by the template {option: 1} */
+    unresolvedProvidedOptions: Map<string, number>;
+    /** This is the list of options that DID get resolved by the options provided {option: num occurrences} */
+    resolvedTemplateOptions: Map<string, number>;
+}
+export interface ITemplateRequirements {
+    /** A string identifier to make it easier to identify which template template failed requirements */
+    name: string;
+    /** The options that must be present within both provided options AND within the template */
+    values: string[];
+}
+export interface ITemplateOptions {
+    /** Double curly brackets for template items instead of one */
+    doubleCurlyBrackets?: boolean;
+    /** This is a key value pair the template uses to match tokens found to replacement values */
+    options: {
+        [key: string]: string;
+    };
+    /** This is used to indicate which tokens are required both within the template AND within the 'options' */
+    required?: ITemplateRequirements;
+    /** This is the template written with templating information */
+    template: string;
+    /** Callback for 'required' errors being emitted */
+    onError?(msg: string): void;
+    /**
+     * Callback that allows overrides for token replacement. Provides the token found and the
+     * suggested replacement for it
+     */
+    onToken?(token: string, replace: string): string;
+}
+/**
+ * This is a method that aids in making templates a bit more dynamic with simple string replacement based on
+ * tokens written into the template. Tokens in the template will appear as ${token} and will either be ignored by this
+ * method and thus removed or will be replaced with a provided value.
+ *
+ * This method will give feedback on the replacements taking place and simplify the process of detecting errors
+ * within the process.
+ */
+export declare function template({ template, doubleCurlyBrackets, options, required, onError, onToken, }: ITemplateOptions): ITemplateResults;

package/dist/utils/to-digits.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Makes a string from a number and adds leading zeros as necessary.
+ */
+export declare function toDigits(n: number, digits: number): string;

package/dist/utils/to-query-params.d.ts

@@ -0,0 +1,14 @@
+export type QueryParams = Map<string, string | string[] | undefined> | Record<string, string | string[] | undefined>;
+/**
+ * Convert a map or an object to query params to send to the server. Provide
+ * tokens to automatically replace ${tokens} in the values of params before
+ * encoding occurs.
+ *
+ * Set repeatLists to cause
+ */
+export declare function toQueryParams(params?: QueryParams, tokens?: Record<string, string>, excludeEmpty?: boolean, repeatLists?: boolean): string;
+/**
+ * Loops through query params and modifies their values to replace any found
+ * ${tokens}.
+ */
+export declare function tokenizeQueryParams(params?: QueryParams, tokens?: Record<string, string>): QueryParams;

package/dist/utils/types.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Interface for declaring a generic JSON valid object
+ */
+export interface IJson {
+    [x: string]: string | number | boolean | Date | IJson | IJsonArray;
+}
+/**
+ * Interface for declaring a generic JSON valid object
+ */
+export interface IJsonType {
+    [x: string]: string | number | boolean | Date | IJsonType | IJsonArray | undefined | null;
+}
+/**
+ * Part of the IJson declaration to make a valid JSON type.
+ */
+export type IJsonArray = (string | number | boolean | Date | IJson | IJsonArray)[];
+/**
+ * This is to help establish a custom child pattern for React. The props for your react component simply needs to extend
+ * this interface.
+ */
+export type IChildren<T extends object> = T & {
+    children?: Partial<T>;
+};
+/**
+ * This lets you define children for a component and forces the children to be declared in the props as opposed to
+ * nesting the children.
+ */
+export type IPropsChildren<T extends object> = T & {
+    children: never;
+};
+/**
+ * This lets you define children for a component and forces the children to be nested as opposed to
+ * being declared in the props.
+ */
+export type INestedChildren<T> = {
+    children?: T;
+};
+/**
+ * A slightly stronger type for indicating "Function". This has greater
+ * flexibility to fit into generic callbacks.
+ */
+export type GenericFunction<T> = (...args: any[]) => T;
+/**
+ * This type is intended for the async operation of a "flow". A flow can have
+ * several yield statements, but are NOT for the intention of returning values
+ * to the caller, but rather for the intent of performing a mobx action that has
+ * asynchronous properties.
+ */
+export type FlowType = Generator<unknown, unknown, unknown> | undefined;
+/**
+ * Typeguard for strings
+ */
+export declare function isString(val: any): val is string;
+/**
+ * Typeguard for numbers
+ */
+export declare function isNumber(val: any): val is number;
+/**
+ * Typeguard for booleans
+ */
+export declare function isBoolean(val: any): val is boolean;
+/**
+ * Typeguard for functions
+ */
+export declare function isFunction(val: any): val is Function;
+/**
+ * Typegaurd for ensuring an element is non-null and not undefined.
+ */
+export declare function isDefined<T>(val: T | undefined | null): val is T;

package/dist/utils/url-join.d.ts

@@ -0,0 +1,24 @@
+/**
+ * MIT License
+ *
+ * Copyright (c) 2015 José F. Romaniello
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+export declare function urlJoin(...args: any[]): string;

package/dist/utils/wait.d.ts

@@ -0,0 +1 @@
+export declare function wait(t: number): Promise<void>;

package/dist/utils/when.d.ts

@@ -0,0 +1,2 @@
+export declare function when<TTest, T, U>(condition: TTest | null | undefined, value: ((condition: TTest) => T) | T): T | U | undefined;
+export declare function when<TTest, T, U>(condition: TTest | null | undefined, value: ((condition: TTest) => T) | T, otherwise: (() => U) | U): T | U;