@elliemae/ds-utilities 3.14.0-next.8 → 3.14.0-rc.0

package/dist/types/algorithms/crossTypeSort.d.ts

@@ -0,0 +1,5 @@
+type ComparisonTerm = string | number | null | undefined;
+type Direction = 'ASC' | 'DESC';
+type SortCB = Required<Parameters<(typeof Array.prototype)['sort']>>[0];
+export declare const crossTypeSort: (a: ComparisonTerm, b: ComparisonTerm, direction?: Direction) => ReturnType<SortCB>;
+export {};

package/dist/types/capitalize.d.ts

@@ -0,0 +1 @@
+export declare const capitalize: (string: string) => string;

package/dist/types/compose.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Composes single-argument functions from right to left. The rightmost
+ * function can take multiple arguments as it provides the signature for
+ * the resulting composite function. [From redux v4.0.5]
+ *
+ * @param {...Function} funcs The functions to compose.
+ * @returns {Function} A function obtained by composing the argument functions
+ * from right to left. For example, compose(f, g, h) is identical to doing
+ * (...args) => f(g(h(...args))).
+ */
+type UnknownFunctionT = (...args: unknown[]) => unknown;
+export declare const compose: (...funcs: UnknownFunctionT[]) => UnknownFunctionT;
+export default compose;

package/dist/types/deprecated/deprecatedMsg.d.ts

@@ -0,0 +1 @@
+export declare const deprecatedMsg = "is going to be deprecated, please consider removing it from your project";

package/dist/types/deprecated/index.d.ts

@@ -0,0 +1,6 @@
+export * from './reactTypesUtility';
+export * from './scrollingTimer';
+export * from './useParentElement';
+export * from './useSetRef';
+export * from './useUncontrolled';
+export * from './useWindowSize';

package/dist/types/deprecated/reactTypesUtility.d.ts

@@ -0,0 +1,5 @@
+export declare function isClassComponent(component: any): boolean;
+export declare function isFunctionComponent(component: any): boolean;
+export declare function isReactComponent(component: any): boolean;
+export declare function isElement(element: Record<string, unknown> | null | undefined): boolean;
+export declare function isCompositeTypeElement(element: Record<string, unknown> | null | undefined): boolean;

package/dist/types/deprecated/scrollingTimer.d.ts

@@ -0,0 +1 @@
+export declare const resetTimer: (func: (...args: unknown[]) => unknown) => (this: any, ...args: unknown[]) => void;

package/dist/types/deprecated/useParentElement.d.ts

@@ -0,0 +1,2 @@
+import type React from 'react';
+export declare const useParentElement: (ref: React.RefObject<HTMLElement>) => ParentNode | null;

package/dist/types/deprecated/useSetRef.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const useSetRef: (initial: unknown) => (import("react").MutableRefObject<unknown> | ((node: any) => void))[];

package/dist/types/deprecated/useUncontrolled.d.ts

@@ -0,0 +1 @@
+export declare const useUncontrolled: (...args: any[]) => any;

package/dist/types/deprecated/useWindowSize.d.ts

@@ -0,0 +1,2 @@
+export declare const useWindowSize: () => number[] | (() => void);
+export default useWindowSize;

package/dist/types/getComponentFromProps.d.ts

@@ -0,0 +1,4 @@
+import type { PropsWithChildren } from 'react';
+import React from 'react';
+export declare const getComponentFromProps: (Component: React.ReactElement<PropsWithChildren<unknown>> | React.ComponentType<unknown>, props: Record<string, unknown>, children?: never[]) => JSX.Element | null;
+export default getComponentFromProps;

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

@@ -0,0 +1,22 @@
+export { default as useMeasure } from 'use-measure';
+export { default as useForceUpdate } from 'use-force-update';
+export { default as useOnClickOutside } from 'use-onclickoutside';
+export { useCallbackAfterRender } from './useCallbackAfterRender';
+export { useCancellableDelayedCallback } from './useCancellableDelayedCallback';
+export { useDerivedStateFromProps } from './useDerivedStateFromProps';
+export { useExecutionTimer } from './useExecutionTimer';
+export { useExpandState } from './useExpandState';
+export { useFocusTrap, UseFocusTrapWithSchema } from './useFocusTrap';
+export { useHotkeys } from './useHotkeys';
+export { useHoverHandlersDelay } from './useHoverHandlersDelay';
+export { useIsMobile } from './useIsMobile';
+export { useIsShowingEllipsis } from './useIsShowingEllipsis';
+export { useMakeMutable } from './useMakeMutable';
+export { useOnBlurOut, UseOnBlurOutWithSchema } from './useOnBlurOut';
+export { useOnElementResize } from './useOnElementResize';
+export { useOnFirstFocusIn, UseOnFirstFocusInWithSchema } from './useOnFirstFocusIn';
+export { useOnSpecificFocus, UseOnSpecificFocusWithSchema } from './useOnSpecificFocus';
+export { usePrevious } from './usePrevious';
+export { useResizeObserver } from './useResizeObserver';
+export { useShouldRecalculate } from './useShouldRecalculate';
+export { useWindowScrollerList } from './useWindowScrollerList';

package/dist/types/hooks/useCallbackAfterRender.d.ts

@@ -0,0 +1,3 @@
+type Callback = (callback: () => void) => void;
+export declare const useCallbackAfterRender: (isLayout?: boolean) => Callback;
+export {};

package/dist/types/hooks/useCancellableDelayedCallback.d.ts

@@ -0,0 +1,3 @@
+type Callback = (...args: unknown[]) => unknown;
+export declare const useCancellableDelayedCallback: (cb: Callback, delay: number) => Callback[];
+export default useCancellableDelayedCallback;

package/dist/types/hooks/useDerivedStateFromProps.d.ts

@@ -0,0 +1,14 @@
+import type React from 'react';
+interface ShouldUpdateArg {
+    prop: unknown;
+    prevProp: unknown;
+    stateValue: unknown;
+}
+type OnUpdateT<T> = (prop: T, prevProp?: T | Record<string, never>) => T;
+interface OptionsT<T> {
+    onUpdate?: OnUpdateT<T>;
+    shouldUpdate?: (arg: ShouldUpdateArg) => boolean;
+    updateOnStateChange?: boolean;
+}
+export declare const useDerivedStateFromProps: <T>(prop: T, options?: OptionsT<T>) => [T, React.Dispatch<React.SetStateAction<T>>];
+export default useDerivedStateFromProps;

package/dist/types/hooks/useDimensions.d.ts

@@ -0,0 +1 @@
+export declare const useDimensions: (domNode: HTMLElement) => DOMRectReadOnly | undefined;

package/dist/types/hooks/useExecutionTimer.d.ts

@@ -0,0 +1,3 @@
+type Callback = (...args: unknown[]) => unknown;
+export declare const useExecutionTimer: (startFn: Callback, cleanFn: Callback, delayTime: number) => Callback[];
+export default useExecutionTimer;

package/dist/types/hooks/useExpandState.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="react" />
+type ItemT = Record<string, string>;
+interface UseExpandStateArg {
+    items?: ItemT[];
+    itemKey?: keyof ItemT;
+    expanded?: Record<string, boolean>;
+    onExpand: (item: ItemT) => void;
+    onExpandChange: (nextState: Record<string, boolean>, item?: ItemT) => void;
+    onExpandAll: (nextState: Record<string, boolean>) => void;
+    onToggleExpand: (item: ItemT) => void;
+    onCollapse: (item: ItemT) => void;
+}
+export declare const useExpandState: ({ items, itemKey, expanded: expandedProp, onExpand, onExpandChange, onExpandAll, onToggleExpand, onCollapse, }: UseExpandStateArg) => {
+    state: {
+        expanded: Record<string, boolean>;
+        isExpandedAll: boolean;
+    };
+    actions: {
+        expand: (item: ItemT, stateData?: boolean) => void;
+        toggleExpandAll: (stateData?: boolean) => void;
+        toggleExpand: (item: ItemT, stateData?: boolean) => void;
+        collapse: (item: ItemT) => void;
+    };
+    setExpanded: import("react").Dispatch<import("react").SetStateAction<Record<string, boolean>>>;
+};
+export default useExpandState;

package/dist/types/hooks/useFocusTrap.d.ts

@@ -0,0 +1,16 @@
+import type React from 'react';
+type UseFocusTrapFunctionT = <T extends HTMLElement = HTMLElement, K extends HTMLElement = HTMLElement>({ firstElementRef, lastElementRef, onKeyDown, }: {
+    firstElementRef: React.MutableRefObject<T | null>;
+    lastElementRef: React.MutableRefObject<K | null>;
+    onKeyDown?: (e: KeyboardEvent) => void;
+}) => (e: KeyboardEvent) => void;
+interface UseFocusTrapT extends UseFocusTrapFunctionT {
+    displayName: 'useFocusTrap';
+}
+declare const useFocusTrap: UseFocusTrapT;
+declare const UseFocusTrapWithSchema: import("../props-helpers/propTypes/types").DocumentedReactComponent<{
+    firstElementRef: React.MutableRefObject<HTMLElement | null>;
+    lastElementRef: React.MutableRefObject<HTMLElement | null>;
+    onKeyDown?: ((e: KeyboardEvent) => void) | undefined;
+}>;
+export { useFocusTrap, UseFocusTrapWithSchema };

package/dist/types/hooks/useHotkeys.d.ts

@@ -0,0 +1,15 @@
+import type { KeyHandler } from 'hotkeys-js';
+type Options = {
+    scope?: string;
+    element?: HTMLElement | null;
+    keyup?: boolean | null;
+    keydown?: boolean | null;
+    splitKey?: string;
+};
+interface UseHotKeysArg {
+    keys: string;
+    options?: Options;
+    handler: KeyHandler;
+}
+export declare const useHotkeys: ({ keys, handler, options }: UseHotKeysArg, deps?: unknown[]) => void;
+export default useHotkeys;

package/dist/types/hooks/useHoverHandlersDelay.d.ts

@@ -0,0 +1,11 @@
+interface UseHoverHandlersDelayArg {
+    onMouseOver: () => void;
+    onMouseLeave: () => void;
+    hideDelay?: number;
+    showDelay?: number;
+}
+export declare const useHoverHandlersDelay: ({ onMouseOver, onMouseLeave, hideDelay, showDelay, }: UseHoverHandlersDelayArg) => {
+    onMouseOver: () => void;
+    onMouseLeave: () => void;
+};
+export default useHoverHandlersDelay;

package/dist/types/hooks/useIsMobile.d.ts

@@ -0,0 +1 @@
+export declare const useIsMobile: () => boolean;

package/dist/types/hooks/useIsShowingEllipsis.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+export declare const useIsShowingEllipsis: <T extends HTMLElement | null = HTMLElement | null>() => {
+    setElement: import("react").Dispatch<import("react").SetStateAction<T | undefined>>;
+    isShowingEllipsis: boolean;
+};

package/dist/types/hooks/useMakeMutable.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+type UseMakeMutable = <T>(referenceVar: T) => React.MutableRefObject<T>;
+export declare const useMakeMutable: UseMakeMutable;
+export {};

package/dist/types/hooks/useOnBlurOut.d.ts

@@ -0,0 +1,10 @@
+import type React from 'react';
+type OnBlurCb = (e: React.FocusEvent, ...args: unknown[]) => void;
+type UseOnBlurOut = ({ onBlur }: {
+    onBlur: OnBlurCb;
+}) => OnBlurCb;
+declare const useOnBlurOut: UseOnBlurOut;
+declare const UseOnBlurOutWithSchema: import("../props-helpers/propTypes/types").DocumentedReactComponent<{
+    onBlur: OnBlurCb;
+}>;
+export { useOnBlurOut, UseOnBlurOutWithSchema };

package/dist/types/hooks/useOnElementResize.d.ts

@@ -0,0 +1,2 @@
+import type React from 'react';
+export declare const useOnElementResize: <T extends HTMLElement>(targetRef: React.RefObject<T>) => Record<'width' | 'height', number>;

package/dist/types/hooks/useOnFirstFocusIn.d.ts

@@ -0,0 +1,16 @@
+import type React from 'react';
+type OnBlurCb = (e: React.FocusEvent, ...args: unknown[]) => void;
+type OnFirstFocusCb = (e: React.FocusEvent, ...args: unknown[]) => void;
+type UseFirstFocusIn = ({ onFirstFocus, onBlur }: {
+    onFirstFocus: OnFirstFocusCb;
+    onBlur: OnBlurCb;
+}) => {
+    onFirstFocus: OnFirstFocusCb;
+    onBlur: OnBlurCb;
+};
+declare const useOnFirstFocusIn: UseFirstFocusIn;
+declare const UseOnFirstFocusInWithSchema: import("../props-helpers/propTypes/types").DocumentedReactComponent<{
+    onFirstFocus: OnFirstFocusCb;
+    onBlur: OnBlurCb;
+}>;
+export { useOnFirstFocusIn, UseOnFirstFocusInWithSchema };

package/dist/types/hooks/useOnSpecificFocus.d.ts

@@ -0,0 +1,10 @@
+import type React from 'react';
+type OnFocusCb = (e: React.FocusEvent, ...args: unknown[]) => void;
+type UseOnBlurOut = ({ onFocus }: {
+    onFocus: OnFocusCb;
+}) => OnFocusCb;
+declare const useOnSpecificFocus: UseOnBlurOut;
+declare const UseOnSpecificFocusWithSchema: import("../props-helpers/propTypes/types").DocumentedReactComponent<{
+    onFocus: OnFocusCb;
+}>;
+export { useOnSpecificFocus, UseOnSpecificFocusWithSchema };

package/dist/types/hooks/usePrevious.d.ts

@@ -0,0 +1,2 @@
+export declare const usePrevious: (value: unknown) => unknown;
+export default usePrevious;

package/dist/types/hooks/useResizeObserver.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+type HandlerT = (measures: {
+    width: number;
+    height: number;
+}, element: Element) => void;
+export declare const useResizeObserver: (handler: HandlerT, el: HTMLElement) => import("react").Dispatch<import("react").SetStateAction<HTMLElement>>[];
+export default useResizeObserver;

package/dist/types/hooks/useShouldRecalculate.d.ts

@@ -0,0 +1,2 @@
+export declare const useShouldRecalculate: (bool: boolean) => number;
+export default useShouldRecalculate;

package/dist/types/hooks/useWindowScrollerList.d.ts

@@ -0,0 +1,7 @@
+import type React from 'react';
+interface UseWindowScrollerListArg {
+    listInstance: React.RefObject<HTMLElement>;
+    outerListRef: React.RefObject<HTMLElement>;
+}
+export declare const useWindowScrollerList: ({ listInstance, outerListRef }: UseWindowScrollerListArg) => void;
+export default useWindowScrollerList;

package/dist/types/index.d.ts

@@ -0,0 +1,16 @@
+export { default as getComponentFromProps } from './getComponentFromProps';
+export { default as onClickHandlerForNonInteractiveElements } from './onClickHandlerForNonInteractiveElements';
+export { capitalize } from './capitalize';
+export { getObjectValuesToArray, getObjectKeysToArray } from './objectUtilities';
+export { checkNotEmpty, checkEmpty, greaterThan, validDate, equal, notEqual, isNull, isNotNull, isIn, isNotIn, greaterThanOrEquals, lessThanOrEquals, startsWith, contains, } from './operators';
+export { cx, runAll, hashArray, safeCall, removeUndefinedProperties, isObject, curry, arrayMove, uniq, filter, uniqBy, groupBy, property, get, set, cloneDeep, debounce, findIndex, isEmpty, isString, isEqual, maxBy, meanBy, noop, omit, orderBy, pull, sortBy, sumBy, transform, isFunction, range, parseInt, padStart, isNaN, values, throttle, toggleInObject, toggleInArray, pick, pickBy, differenceBy, differenceWith, addOrRemove, isEqualWith, isBoolean, } from './utils';
+export { setRef, mergeRefs, setMultipleRefs, logger } from './system';
+export { useMeasure, useForceUpdate, useOnClickOutside, useExecutionTimer, useExpandState, useHotkeys, useHoverHandlersDelay, useResizeObserver, useShouldRecalculate, useWindowScrollerList, usePrevious, useCancellableDelayedCallback, useDerivedStateFromProps, useOnElementResize, useIsShowingEllipsis, useMakeMutable, useCallbackAfterRender, useFocusTrap, UseFocusTrapWithSchema, useIsMobile, useOnBlurOut, UseOnBlurOutWithSchema, useOnFirstFocusIn, UseOnFirstFocusInWithSchema, useOnSpecificFocus, UseOnSpecificFocusWithSchema, } from './hooks';
+export { getVisibleTimeByFormat, addLeadingZeros } from './timeUtils';
+export { compose } from './compose';
+export { DOCUMENT, WINDOW } from './platform';
+export { isDOMTypeElement } from './reactTypesUtility';
+export { isRequired, isGreaterThan, isValidDate } from './validations';
+export { crossTypeSort } from './algorithms/crossTypeSort';
+export * from './deprecated';
+export * from './props-helpers';

package/dist/types/objectUtilities.d.ts

@@ -0,0 +1,2 @@
+export declare const getObjectValuesToArray: (obj: Record<string, unknown>) => string[] | null;
+export declare const getObjectKeysToArray: (obj: Record<string, unknown>) => string[] | null;

package/dist/types/onClickHandlerForNonInteractiveElements.d.ts

@@ -0,0 +1,8 @@
+import type React from 'react';
+export declare const onClickHandlerForNonInteractiveElements: (onClickHandler: React.MouseEventHandler & React.KeyboardEventHandler) => {
+    role: string;
+    tabIndex: string;
+    onClick: React.MouseEventHandler<Element> & React.KeyboardEventHandler<Element>;
+    onKeyPress: (event: React.KeyboardEvent) => void;
+};
+export default onClickHandlerForNonInteractiveElements;

package/dist/types/operators.d.ts

@@ -0,0 +1,14 @@
+export declare const checkNotEmpty: (value: unknown) => boolean;
+export declare const checkEmpty: (value: unknown) => boolean;
+export declare const greaterThan: (value: number, comparator: number) => boolean;
+export declare const validDate: (value: string) => boolean;
+export declare const equal: (a: unknown, b: unknown) => boolean;
+export declare const notEqual: (a: unknown, b: unknown) => boolean;
+export declare const isNull: (a: unknown) => boolean;
+export declare const isNotNull: (a: unknown) => boolean;
+export declare const isIn: <T>(a: T, b: T[]) => boolean;
+export declare const isNotIn: <T>(a: T, b: T[]) => boolean;
+export declare const greaterThanOrEquals: (value: number, comparator: number) => boolean;
+export declare const lessThanOrEquals: (value: number, comparator: number) => boolean;
+export declare const startsWith: (value: unknown, comparator: string) => boolean;
+export declare const contains: (value: unknown, comparator: string) => boolean;

package/dist/types/platform.d.ts

@@ -0,0 +1,2 @@
+export declare const DOCUMENT: Document | null;
+export declare const WINDOW: (Window & typeof globalThis) | null;

package/dist/types/props-helpers/defaultProps/index.d.ts

@@ -0,0 +1 @@
+export * from './useMemoMergePropsWithDefault';

package/dist/types/props-helpers/defaultProps/useMemoMergePropsWithDefault.d.ts

@@ -0,0 +1 @@
+export declare const useMemoMergePropsWithDefault: <T = Record<string, any>>(props: Partial<T>, defaultProps: Partial<T>, compare?: (a: any, b: any) => boolean) => T;

package/dist/types/props-helpers/getProps/index.d.ts

@@ -0,0 +1,2 @@
+export declare const getAriaProps: <T extends Record<string, unknown> = Record<string, unknown>>(props: T) => Record<string, unknown>;
+export declare const getDataProps: <T extends Record<string, unknown> = Record<string, unknown>>(props: T) => Record<string, unknown>;

package/dist/types/props-helpers/globalProps/constants.d.ts

@@ -0,0 +1,3 @@
+import type { AriaAttributes, DOMAttributes, HTMLAttributes } from 'react';
+export type GlobalAttributes<T = true> = Record<keyof (AriaAttributes & DOMAttributes<Element> & HTMLAttributes<Element>), T>;
+export declare const globalAttributes: GlobalAttributes<true>;

package/dist/types/props-helpers/globalProps/getGlobalAttributes.d.ts

@@ -0,0 +1,6 @@
+import type { AllHTMLAttributes, AriaAttributes, DOMAttributes, HTMLAttributes } from 'react';
+import type { GlobalAttributes } from './constants';
+export type GlobalAttributesT<T = Element> = AriaAttributes & DOMAttributes<T> & HTMLAttributes<T> & Omit<AllHTMLAttributes<T>, 'as'> & {
+    tabIndex?: WCAGTabIndex;
+};
+export declare const getGlobalAttributes: <T, S = Element>(props: T, overrides?: Partial<GlobalAttributes<CallableFunction>>) => GlobalAttributesT<S>;