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

package/dist/utils/chalk.d.ts

@@ -0,0 +1,44 @@
+export declare const chalk: {
+    cyan: (...text: string[]) => string;
+    red: (...text: string[]) => string;
+    yellow: (...text: string[]) => string;
+    green: (...text: string[]) => string;
+    blue: (...text: string[]) => string;
+    magenta: (...text: string[]) => string;
+    cyanBright: (...text: string[]) => string;
+    redBright: (...text: string[]) => string;
+    yellowBright: (...text: string[]) => string;
+    greenBright: (...text: string[]) => string;
+    blueBright: (...text: string[]) => string;
+    magentaBright: (...text: string[]) => string;
+    whiteBright: (...text: string[]) => string;
+    gray: (...text: string[]) => string;
+    grey: (...text: string[]) => string;
+    white: (...text: string[]) => string;
+    black: (...text: string[]) => string;
+    blackBright: (...text: string[]) => string;
+    bgCyan: (...text: string[]) => string;
+    bgRed: (...text: string[]) => string;
+    bgYellow: (...text: string[]) => string;
+    bgGreen: (...text: string[]) => string;
+    bgBlue: (...text: string[]) => string;
+    bgMagenta: (...text: string[]) => string;
+    bgCyanBright: (...text: string[]) => string;
+    bgRedBright: (...text: string[]) => string;
+    bgYellowBright: (...text: string[]) => string;
+    bgGreenBright: (...text: string[]) => string;
+    bgBlueBright: (...text: string[]) => string;
+    bgMagentaBright: (...text: string[]) => string;
+    cyanBrightBold: (...text: string[]) => string;
+    redBrightBold: (...text: string[]) => string;
+    yellowBrightBold: (...text: string[]) => string;
+    greenBrightBold: (...text: string[]) => string;
+    blueBrightBold: (...text: string[]) => string;
+    magentaBrightBold: (...text: string[]) => string;
+    whiteBrightBold: (...text: string[]) => string;
+    grayBrightBold: (...text: string[]) => string;
+    greyBrightBold: (...text: string[]) => string;
+    whiteBold: (...text: string[]) => string;
+    blackBold: (...text: string[]) => string;
+    blackBrightBold: (...text: string[]) => string;
+};

package/dist/utils/chunk.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Breaks an array into chunks
+ */
+export declare function chunk<T>(array: T[], size: number): T[][];

package/dist/utils/classnames.d.ts

@@ -0,0 +1,6 @@
+/**
+ * This takes several arguments and concatenates them into a single css class
+ * name compatible string. It will remove any falsy values and will trim any
+ * whitespace.
+ */
+export declare function classnames(...str: (string | undefined | null)[]): string;

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

@@ -0,0 +1,26 @@
+/**
+ * Padding values to grow a client rect during a client rect cloning operation.
+ */
+export type DOMRectPadding = {
+    left?: number;
+    top?: number;
+    bottom?: number;
+    right?: number;
+};
+export type DOMRectBounds = {
+    x: number;
+    y: number;
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+    width: number;
+    height: number;
+};
+/**
+ * ClientRects are a bit annoying to work around their immutability if needed.
+ * This properly makes a Mutable clone without altering the original (unless
+ * padding is specified to do a one time change of the bounds. The padding
+ * expands/contracts the box on the indicated sides).
+ */
+export declare function cloneClientRect(box?: DOMRectBounds, padding?: DOMRectPadding): DOMRectBounds;

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

@@ -0,0 +1,5 @@
+import { DOMRectBounds } from './clone-client-rect';
+/**
+ * Compares two client rects against each other.
+ */
+export declare function compareClientRect(a?: DOMRectBounds | null, b?: DOMRectBounds | null): boolean;

package/dist/utils/compare-sets.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Coompares two sets to see if each set is equal to each other in size and in
+ * content.
+ */
+export declare function compareSets(a: Set<any>, b: Set<any>): boolean;

package/dist/utils/compose-refs.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+/**
+ * Applies a component's ref to multiple refs
+ */
+export declare function composeRefs<T>(...refs: (React.Ref<T> | undefined)[]): (n: T) => void;

package/dist/utils/cookie-parser.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Parses the current cookies for this application into an easier to use JSON
+ * object.
+ *
+ * If a cookie is not passed as an argument, this will parse the cookie found on
+ * the document (in browser. In Node an argument is required).
+ */
+export declare function cookieParser(manual?: string): Record<string, string>;

package/dist/utils/copy-text-to-clipboard.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The intent of this function is to provide the most reliable means to copy
+ * text to the clipboard. This provides some attempts ranging far back for older
+ * browser support and even falls back to a window prompt if everything
+ * automatic fails.
+ */
+export declare function copyTextToClipboard(text: string): Promise<void>;

package/dist/utils/debounce.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Debounce decorator for methods
+ */
+export declare function debounce(timeout: number | undefined, method: Function): () => void;

package/dist/utils/deep-clone.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Creates a deeply cloned copy of the given object and handles circular
+ * references.
+ */
+export declare function deepClone<T extends object>(obj: T): T;

package/dist/utils/deep-equal.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Compares all properties deeply between two objects for equality.
+ */
+export declare function deepEqual<T extends Record<keyof T, any>, U extends Record<keyof U, any>>(a: T, b: U, checked?: Set<any>): boolean;

package/dist/utils/ensure-modal-root.d.ts

@@ -0,0 +1,4 @@
+/**
+ * This guarantees the modal root to exist at the body root level
+ */
+export declare function ensureModalRoot(customId?: string): HTMLDivElement;

package/dist/utils/event-element-position.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Analyzes a MouseEvent and calculates the mouse coordinates (relative to the element).
+ */
+export declare function eventElementPosition(e: any, relative?: HTMLElement): [number, number];

package/dist/utils/filter-react-children.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+/**
+ * This is a helper method to retrieve only a single type of child component
+ * from a React children list. This accounts for nested React fragments.
+ */
+export declare function filterReactChildren<T>(type: T | T[], children: React.ReactNode, fail?: (child: React.ReactNode) => void): React.ReactNode[];

package/dist/utils/find-react-children.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+type GroupMap = Map<string | React.JSXElementConstructor<any> | React.JSXElementConstructor<any>, React.ReactNode[]>;
+/**
+ * This is a helper method to seek out specific react children in the tree of
+ * children provided to this function. If a child is not of a type specified,
+ * this will search through it's children as well to see if any descendents
+ * match.
+ */
+export declare function findReactChildren(types: (string | React.JSXElementConstructor<any>)[], children: React.ReactNode): GroupMap;
+export {};

package/dist/utils/flatten-array.d.ts

@@ -0,0 +1,5 @@
+/**
+ * A non-recursive method to flatten an input array of items or list to a single
+ * array
+ */
+export declare function flattenArray<T>(arr: (T | T[])[]): T[];

package/dist/utils/fuzzy-groups.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Results for a fuzzyGroups query.
+ */
+export interface IFuzzyGroupResult {
+    /**
+     * Groupings of the fuzzy results. You can concat the text values in the order
+     * of this array to reconstruct the original text term. isMatch will be true
+     * when the fuzzy search made a match for the group.
+     */
+    groups: {
+        isMatch: boolean;
+        text: string;
+    }[];
+    /**
+     * When true, the complete fuzzy search term is completely found within this
+     * result. Otherwise, only part or none of the fuzzy term was used.
+     */
+    fuzzyMatch: boolean;
+    /**
+     * Indicates how much of the fuzzy term was utilized in the result. A 1 means
+     * fuzzyMatch is true. Anything less than 1 is how much less it was used
+     * within the result.
+     */
+    fuzzyMatchStrength: number;
+    /**
+     * The original text the string was compared against
+     */
+    text: string;
+    /**
+     * The fuzzy term that was used to compare against the text.
+     */
+    fuzzy: string;
+}
+/**
+ * Typeguard for a fuzzy group result type
+ */
+export declare function isFuzzyGroupResult(val: any): val is IFuzzyGroupResult;
+/**
+ * Returns fuzzy text matching results.
+ *
+ * This will provide the fuzzy match with the characters in the list grouped by
+ * how they match with the fuzzy text.
+ *
+ * You combine all of the group text vaues to recreate the original text input.
+ * Use the isMatch to determine if the group is a part of a match from the fuzzy
+ * input.
+ *
+ * fuzzyMatch is true when the complete fuzzy term matches items within the
+ * text. It's false if only part of the fuzzy term or none of the term matches.
+ */
+export declare function fuzzyGroups(text: string, fuzzy: string): IFuzzyGroupResult;

package/dist/utils/get-decimal.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Simple function for getting a number up to a certain decimal. This properly
+ * returns a number to work with. This is for special formatting and should not
+ * be used for mathematical operations.
+ *
+ * This specifically rounds up the final decimal value.
+ */
+export declare function getDecimal(value: number | string, decimalPlaces: number): number;

package/dist/utils/get-error-message.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Errors can not have a type specified in the try catch clause. This makes
+ * outputting an error message safe and easier to type by doing validations
+ * necessary to get a standard error's error message or stack.
+ */
+export declare function getErrorMessage(e: unknown): string;

package/dist/utils/get-first-with-class.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Searches up the DOM tree for the first instance of a given class to be
+ * located. If none exists no result will be returned.
+ */
+export declare function getFirstWithClass(element: HTMLElement, className: string): HTMLElement | null;

package/dist/utils/get-index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Mobx does NOT like retrieving out of bounds on an array. This is a warning
+ * safe way to do the retrieval.
+ */
+export declare function getIndex<T>(list: T[], index: number): T | undefined;

package/dist/utils/get-selected-text.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Method for current and older browsers to detect current selected text.
+ */
+export declare function getSelectedText(): string;

package/dist/utils/get-type-name.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+/**
+ * JSX types are created as strings or via function components or class
+ * components. There is an interesting issue with matching on "type" where two
+ * versions of the same library could cause matches to fail because they can
+ * bundle and point to two separate versions of the same component but be two
+ * different objects entirely.
+ *
+ * THUS: a more reliable matching approach is to check on the string "name" of
+ * the type as best as possible. This method normalizes retrieving the type name
+ * from the component by addressing the different component types that can be
+ * created and passed out.
+ */
+export declare function getTypeName(type: string | React.ReactElement | React.ComponentType<any> | React.JSXElementConstructor<any> | Function): string;

package/dist/utils/group-react-children.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+type GroupMap = Map<string | React.JSXElementConstructor<any> | React.JSXElementConstructor<any>, React.ReactNode[]>;
+/**
+ * This is a helper method to sort a list of react children into groups, based
+ * on their type. This accounds for nested React Fragments.
+ */
+export declare function groupReactChildren(children: React.ReactNode): GroupMap;
+export {};

package/dist/utils/has-child.d.ts

@@ -0,0 +1,4 @@
+/**
+ * This checks to see if the specified child IS a child of the indicated parent.
+ */
+export declare function hasChild(parent: HTMLElement | null, child: HTMLElement | null): boolean;

package/dist/utils/hooks/index.d.ts

@@ -0,0 +1 @@
+export { default as useHover } from './use-hover';

package/dist/utils/hooks/use-hover.d.ts

@@ -0,0 +1,10 @@
+export default function useHover({ onEnter, onLeave, }?: {
+    onEnter?: () => void;
+    onLeave?: () => void;
+} | undefined): {
+    hovered: boolean;
+    handlers: {
+        onMouseEnter: () => void;
+        onMouseLeave: () => void;
+    };
+};

package/dist/utils/index.d.ts

@@ -0,0 +1,43 @@
+export * from './add-font';
+export * from './after-render';
+export * from './async-dom-render';
+export * from './chalk';
+export * from './chunk';
+export * from './classnames';
+export * from './clone-client-rect';
+export * from './compare-client-rect';
+export * from './compare-sets';
+export * from './compose-refs';
+export * from './cookie-parser';
+export * from './copy-text-to-clipboard';
+export * from './debounce';
+export * from './deep-clone';
+export * from './deep-equal';
+export * from './ensure-modal-root';
+export * from './event-element-position';
+export * from './filter-react-children';
+export * from './flatten-array';
+export * from './fuzzy-groups';
+export * from './get-decimal';
+export * from './get-error-message';
+export * from './get-first-with-class';
+export * from './get-index';
+export * from './get-selected-text';
+export * from './group-react-children';
+export * from './has-child';
+export * from './make-buffer';
+export * from './map-lookup-values';
+export * from './no-op';
+export * from './normalize-wheel';
+export * from './promise-resolver';
+export * from './relative-client-rect';
+export * from './rush';
+export * from './state-controls';
+export * from './stop-all-propagation';
+export * from './template';
+export * from './to-digits';
+export * from './to-query-params';
+export * from './types';
+export * from './url-join';
+export * from './wait';
+export * from './when';

package/dist/utils/local-storage.d.ts

@@ -0,0 +1,42 @@
+import { IJson } from './types';
+/**
+ * Retrieve a number from local storage. If the identifier is NOT a number OR is
+ * not a data type stored using this system it will merely return void.
+ */
+export declare function getStorageNumber(id: string): number | undefined;
+/**
+ * Retrieve a string from local storage.
+ */
+export declare function getStorageString(id: string): string | undefined;
+/**
+ * Retrieves a JSON object from local storage. If the identifier is NOT a JSON
+ * object, this will return void;
+ */
+export declare function getStorageObject(id: string): IJson | undefined;
+/**
+ * Retrieve a boolean from local storage. If the item does not exist this will
+ * return false.
+ */
+export declare function getStorageBoolean(id: string): boolean;
+/**
+ * Apply a number to local storage. If a different data type exists for the
+ * given identifier that is already set, this will return false. Set override to
+ * true to force setting the value regardless of previous value.
+ */
+export declare function setStorageNumber(id: string, val: number, override?: boolean): boolean;
+/**
+ * Apply a string from local storage. This will always override the current
+ * value regardless of type as it's not easy to determine if a string or a
+ * number was put into the
+ */
+export declare function setStorageString(id: string, val: string, override?: boolean): boolean;
+/**
+ * Applys a JSON object from local storage. If the identifier is NOT a JSON
+ * object, this will return void;
+ */
+export declare function setStorageObject(id: string, val: IJson, override?: boolean): IJson | undefined;
+/**
+ * Apply a boolean from local storage. If the item does not exist this will
+ * return false.
+ */
+export declare function setStorageBoolean(id: string, val: boolean, override?: boolean): boolean;

package/dist/utils/make-buffer.d.ts

@@ -0,0 +1,28 @@
+/**
+ * This static class provides a utility for creating an array buffer and mapping
+ * it's values to an initial value or simply create an initial array that is
+ * iterable.
+ *
+ * Purpose: This utility was created to get around issues with default JS means
+ * of generating arrays. All of the "native" means are incredibly slow and have
+ * issues with creating double instances of arrays or doing multiple iterations
+ * across the size of the array.
+ *
+ * This ensures a single allocation and a single iteration of the array which is
+ * optimal. Currently, these methods beat the normal native means significantly.
+ */
+export declare class MakeBuffer {
+    /**
+     * Create and fill a buffer with intiial values.
+     */
+    static map<T>(size: number, map: (index: number) => T): T[];
+    /**
+     * Create a buffer with initial values applied.
+     */
+    static init<T>(size: number, initialValue: T): T[];
+    /**
+     * Creates a buffer that begins at the provided value and ends exclusive of
+     * the end value. You can provide a step value to increase the buffer by.
+     */
+    static range(start: number, end: number, step?: number): number[];
+}

package/dist/utils/map-lookup-values.d.ts

@@ -0,0 +1,65 @@
+/**
+ * A special type that allows deep nesting of identifiers before ultimately
+ * landing on a specific type at the leaves of the object.
+ */
+export type Lookup<T> = {
+    [key: string]: T | Lookup<T>;
+};
+/**
+ * A special type that allows deep nesting of identifiers before ultimately
+ * landing on a specific type at the leaves of the Map.
+ */
+export type LookupMap<T> = Map<string, T | LookupMap<T>>;
+/**
+ * Using a list of keys, this injects a value deeply into a Map object as a tree
+ * structure.
+ */
+export declare function deepInjectMap<T>(key: string[], target: LookupMap<T>, value: T): LookupMap<T> | null;
+/**
+ * Using a list of keys, this retrieves a value deeply from a Map object that
+ * has a tree structure.
+ */
+export declare function deepGet<T>(key: string[], target: LookupMap<T>): LookupMap<T> | T | undefined;
+export type LookupNode<T> = {
+    id: string[];
+    data: T[];
+    children: LookupNode<T>[];
+};
+/**
+ * Flattened node structure. This provides some indexing numbers to aid in
+ * looping through the flatened structure.
+ *
+ * next sibling and parent index is -1 when there is no sibling or parent.
+ *
+ * [depth, node, parent index, next sibling]
+ */
+export type FlattenedLookupNode<T> = [
+    number,
+    T | LookupNode<T>,
+    number,
+    number
+][];
+/**
+ * Converts a Map tree structure into Nodes.
+ *
+ * TODO: don't use recursion. This is the quick way to implement. This will
+ * crash on circular map dependency.
+ */
+export declare function mapToNodes<T extends {
+    nodeId?: string[];
+}>(map: LookupMap<T>, nodeComplete?: (node: LookupNode<T>) => void, id?: string[]): LookupNode<T>;
+/**
+ * Flattens a LookupNode to a simple list with
+ */
+export declare function flattenNodeData<T>(node: LookupNode<T>, depth?: number, parentIndex?: number, out?: FlattenedLookupNode<T>): FlattenedLookupNode<T>;
+/**
+ * Converts an object Lookup to a LookupMap
+ *
+ * TODO: Don't use recursion
+ */
+export declare function makeLookupMap<T>(lookup: Lookup<T>, typeGuard: (value: any) => value is T): LookupMap<T>;
+/**
+ * A very tricky method that maps a Lookup (dictionary with nested keys) to
+ * values found in the leaves of the tree of the object.
+ */
+export declare function mapLookupValues<T, U>(label: string, typeGuard: (value: T | Lookup<T>) => value is T, lookup: Lookup<T>, callback: (key: string[], value: T) => U): U[];

package/dist/utils/no-op.d.ts

@@ -0,0 +1,4 @@
+/**
+ * A method that does nothing. Useful for defaulting callbacks or placing stubs.
+ */
+export declare const NOOP: () => void;

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

@@ -0,0 +1,38 @@
+/**
+  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.
+*/
+/**
+ * Simple, lightweight module assisting with the detection and context of
+ * Worker. Helps avoid circular dependencies and allows code to reason about
+ * whether or not they are in a Worker, even if they never include the main
+ * `ReactWorker` dependency.
+ */
+declare var ExecutionEnvironment: any;
+export default ExecutionEnvironment;