@ringcentral/spring-base 1.7.0 → 1.8.0

package/src/hooks/useMountState/useMountState.d.ts

@@ -1,16 +1,2 @@
 /// <reference types="react" />
-/**
- * get that component mounted state `ref`
- *
- * @example
- *
- * ```ts
-    const isMountedRef = useMountState();
-
-    if (isMountedRef.current) {
-      console.log('component mounted');
-    }
- *
- * ```
- */
 export declare const useMountState: () => import("react").MutableRefObject<boolean>;

package/src/hooks/useOnLayoutReRender/useOnLayoutReRender.d.ts

@@ -1,5 +1,2 @@
 import { DependencyList } from 'react';
-/**
- * only trigger when re-render (in useLayoutEffect), not trigger on component first render
- */
 export declare const useOnLayoutReRender: (cb: () => any, deps?: DependencyList | undefined) => void;

package/src/hooks/useOnReRender/useOnReRender.d.ts

@@ -1,5 +1,2 @@
 import { DependencyList } from 'react';
-/**
- * only trigger when re-render, not trigger on component first render
- */
 export declare const useOnReRender: (cb: () => any, deps?: DependencyList | undefined) => void;

package/src/hooks/useOverflow/useOverflow.d.ts

@@ -1,8 +1,5 @@
 import { RefOrElementOrCallback } from '../../utils';
 import { PerformanceOptions } from '../useResizeObserver';
-/**
- * trigger when overflow state change
- */
 export declare const useOverflow: (target: RefOrElementOrCallback, cb: (state: boolean, value: {
     scrollWidth: number;
     clientWidth: number;

package/src/hooks/usePrevious/usePrevious.d.ts

@@ -1,7 +1 @@
-/**
- * get previous render value
- * @param cb that get method of target value
- * @param isDefault if set `true`, the first time will get value from `cb`
- * @returns previous value get from `cb`
- */
 export declare function usePrevious<T, K extends boolean>(cb: () => T, isDefault?: K): T | (K extends true ? never : undefined);

package/src/hooks/useRefState/useRefState.d.ts

@@ -1,21 +1,2 @@
 /// <reference types="react" />
-/**
- * Returns a stateful like state with Ref, and a function to update it current value.
- * can trigger update value without re-render
- *
- * @param value init value
- * @param customUpdate you can custom you update method, or just set your `forceUpdate` to reuse same instance
- * @returns an array with [ref, update]
- *
- * @example
- * ```ts
- * const [inputRef, updateInput] = useRefState(123);
- *
- * if(needReRender){
- *   updateInput(456); // trigger re-render
- * } else {
- *   updateInput(456, false); // not trigger re-render
- * }
- * ```
- */
 export declare const useRefState: <T>(value: T, customUpdate?: (() => void) | undefined) => readonly [import("react").MutableRefObject<T>, (toValue: T, isUpdate?: any) => void];

package/src/hooks/useResizeObserver/useResizeObserver.d.ts

@@ -1,24 +1,9 @@
 import { type DebounceSettings, type ThrottleSettings } from 'lodash';
 import { RefOrElementOrCallback } from '../../utils';
 export declare type PerformanceOptions = {
-    /**
-     * mode that improve performance, default is debounce
-     *
-     * throttle is better than debounce when use for responsive UI
-     */
     mode?: 'debounce' | 'throttle' | 'none';
-    /** debounce time or throttle time when resize, default is 200 */
     time?: number;
-    /** ignore fire when observe */
     ignoreFireWhenObserve?: boolean;
-    /** setting about debounce or throttle */
     options?: ThrottleSettings | DebounceSettings;
 };
-/**
- * get resize event with auto disconnect when layout destroy.
- * bring with debounce for event not too many
- * @param ref that ref for element
- * @param callback callback when element resize
- * @param performance options that improve performance
- */
 export declare const useResizeObserver: <T extends HTMLElement = HTMLElement>(target: RefOrElementOrCallback<T>, callback: ResizeObserverCallback, performance?: PerformanceOptions) => ResizeObserver;

package/src/hooks/useResponsiveMatch/useResponsiveMatch.d.ts

@@ -1,7 +1,3 @@
 import { BreakpointMatchMap, MatchedBreakpoint } from '../../contexts';
-/**
- * get all matched breakpoints
- * @param defaultBreakpoint use defaultBreakpoint when Responsive init (will pass undefined)
- */
 declare const useResponsiveMatch: (defaultBreakpoint?: MatchedBreakpoint | undefined) => BreakpointMatchMap;
 export { useResponsiveMatch };

package/src/hooks/useResultRef/useResultRef.d.ts

@@ -1,10 +1,2 @@
 import { MutableRefObject } from 'react';
-/**
- * provide a ref for only calculate `cb` once
- * prevent `useRef(getValue())`, that `getValue` calculate every re-render
- *
- * @param cb that get method of get this ref init value, only calculate once
- * @returns same as `useRef` result
- *
- */
 export declare function useResultRef<T>(cb: () => T): MutableRefObject<T>;

package/src/hooks/useRetry/useRetry.d.ts

@@ -1,35 +1,12 @@
 export declare type UseRetryOptions = {
-    /** times count that retry when `cb` return `false` */
     retryTimes: number;
-    /** retry interval time */
     intervalTime: number;
-    /** trigger when retry start */
     onStart?: () => void;
-    /** trigger when retry be cancel */
-    onSuccess?: (
-    /** retry times */
-    times?: number) => void;
-    /** trigger when retry complete */
-    onComplete?: (
-    /** retry times */
-    times?: number) => void;
-    /** trigger when retry be cancel */
+    onSuccess?: (times?: number) => void;
+    onComplete?: (times?: number) => void;
     onCancel?: () => void;
 };
-/**
- * retry times when exec callback fail
- *
- * * `retry`: that will auto add `times` end of your call back
- * * `cancel`: cancel that retry event, that only cancel inner interval promise, **if you need cancel your `cb` promise, you should handle by yourself.**
- */
 export declare const useRetry: <T extends (...args: any[]) => boolean | Promise<boolean>>(cb: T, options?: UseRetryOptions | undefined) => {
-    /**
-     * retry method, that will be cancelable with `cancel`,
-     * and when trigger many time that will always clear previous retry
-     */
     retry: (...args: Parameters<T>) => Promise<void>;
-    /**
-     * cancel current retry
-     */
     cancel: () => void;
 };

package/src/hooks/useSleep/useSleep.d.ts

@@ -1,22 +1,5 @@
-/**
- * cancelable sleep method.
- *
- * - sleep: a promise sleep
- * - cancel: cancel that sleep event
- * - getSleeping: get current sleeping state
- */
 export declare const useSleep: () => {
-    /**
-     * sleep method, that will be cancelable with `cancel`,
-     * and when trigger many time that will always clear previous sleep
-     */
     sleep: (time: number) => Promise<void>;
-    /**
-     * cancel current sleep timer
-     */
     cancel: () => void;
-    /**
-     * return is current is sleeping
-     */
     getSleeping: () => boolean;
 };

package/src/hooks/useTabOut/useTabOut.d.ts

@@ -1,6 +1,3 @@
-/**
- * @param onTabOut Callback fired when a "tab out" event is detected.
- */
 export declare const useTabOut: (onTabOut: (e: React.FocusEvent<HTMLDivElement>) => void) => {
     tabOutHandler: {
         onKeyDown: (e: React.KeyboardEvent<HTMLDivElement>) => void;

package/src/hooks/useTestRunnerDetection.d.ts

@@ -1,7 +1 @@
-/**
- * Internal hook to detect if the component is running in a test runner environment
- * Used by Storybook stories to disable network requests and animations during testing
- * @returns {boolean} true if running in test runner (headless browser), false otherwise
- * @internal
- */
 export declare const useTestRunnerDetection: () => boolean;

package/src/hooks/useThrottle/useThrottle.d.ts

@@ -1,8 +1,2 @@
 import type { ThrottleSettings } from 'lodash';
-/**
- * provide a throttle method for throttle method
- * @param fn method for throttle
- * @param throttleTime throttle timeout value, default is  `200`ms
- * @param options throttle setting, default is  `{trailing: true, leading: true}`, detail see lodash
- */
 export declare const useThrottle: <F extends (...args: any[]) => any>(fn: F, throttleTime?: number, options?: ThrottleSettings | undefined) => import("lodash").DebouncedFunc<F>;

package/src/hooks/useTouchMouseEvent/useTouchMouseEvent.d.ts

@@ -1,16 +1,8 @@
 import { MouseEventHandler, TouchEventHandler } from 'react';
 import { RefOrElementOrCallback } from '../../utils';
 export interface UseTouchMouseEvent<T> extends Partial<UseTouchMouseOutputEvent<T>> {
-    onTouchEnd?: (event: React.TouchEvent<T>, 
-    /**
-     * when set insideRef, that will also emit the state of host reference contain pointer element when action stop
-     */
-    isInside?: boolean) => void;
-    onMouseUp?: (event: React.MouseEvent<T, globalThis.MouseEvent>, 
-    /**
-     * when set insideRef, that will also emit the state of host reference contain pointer element when action stop
-     */
-    isInside?: boolean) => void;
+    onTouchEnd?: (event: React.TouchEvent<T>, isInside?: boolean) => void;
+    onMouseUp?: (event: React.MouseEvent<T, globalThis.MouseEvent>, isInside?: boolean) => void;
 }
 export interface UseTouchMouseOutputEvent<T> {
     onMouseUp: MouseEventHandler<T>;
@@ -19,38 +11,7 @@ export interface UseTouchMouseOutputEvent<T> {
     onTouchStart: TouchEventHandler<T>;
 }
 export interface UseTouchMouseEventOptions<T extends HTMLElement> {
-    /**
-     * when set that elementRef, event will bring with leave state when `touchend` and `mouseup`
-     *
-     * stop action event in browser default can be trigger when `touchend`, `mouseup` outside target element,
-     * set that host ref to make sure `touchend`, `mouseup` event only trigger when release inside target element
-     */
     actionRef?: RefOrElementOrCallback<T>;
 }
-/**
- * Provide a utils for switch trigger touch event or mouse event between different device
- *
- * - Trigger `touch` event in `touch support` device
- *   - onTouchStart
- *   - onTouchEnd
- * - Trigger `mouse` event in `non touch support` device
- *   - onMouseDown
- *   - onMouseUp
- *
- * ### Once that is touch support device, that mouse event will never can be trigger
- * https://developer.mozilla.org/en-US/docs/Web/API/Touch_events/Supporting_both_TouchEvent_and_MouseEvent
- *
- * Event order:
- * - touchstart
- * - Zero or more touchmove events, depending on movement of the finger(s)
- * - touchend
- * - mousemove
- * - mousedown
- * - mouseup
- * - click
- */
 export declare const useTouchMouseEvent: <T extends HTMLElement = HTMLElement>({ onMouseDown: onMouseDownArg, onMouseUp: onMouseUpArg, onTouchStart: onTouchStartArg, onTouchEnd: onTouchEndArg, }: UseTouchMouseEvent<T>, { actionRef }?: UseTouchMouseEventOptions<T>) => UseTouchMouseOutputEvent<T>;
-/**
- * check is element equal or contains target element
- */
 export declare const isElmEqualOrContain: (sourceTarget: RefOrElementOrCallback, containTarget: RefOrElementOrCallback) => boolean;

package/src/typings/BaseColor.d.ts

@@ -4,7 +4,6 @@ declare type DefaultBaseColor = {
     inherit: any;
     default: any;
     error: any;
-    /**  */
     positive: any;
     negative: any;
     action: any;

package/src/typings/ComponentTypes.d.ts

@@ -2,44 +2,18 @@ import type { MotionProps } from 'framer-motion';
 import type { ComponentPropsWithRef, ElementType, HTMLAttributes, LegacyRef } from 'react';
 import type { GlobalStateClassesKey } from '../utils/classes/globalStateClasses';
 export declare type GroupedMotionProps<P = {}> = Pick<MotionProps, Extract<keyof HTMLAttributes<Element>, keyof MotionProps>> & Omit<P, Extract<keyof HTMLAttributes<Element>, keyof MotionProps>> & {
-    /** Override the motion applied to the component */
     motionProps?: MotionProps | null;
 };
 export declare type ClassesProp<K extends string> = {
-    /** Override or extend the styles applied to the component */
     classes?: Partial<Record<K | 'root' | GlobalStateClassesKey, string>>;
 };
 export declare type PropsWithRoot<P, R extends ElementType, O extends string = ''> = P & Omit<ComponentPropsWithRef<R>, keyof P | O>;
 export declare type StandardProps<P, C extends string, R extends ElementType | void = void, O extends string = '', ExtendAttributes = HTMLDataAttribute> = ClassesProp<C> & (R extends ElementType ? PropsWithRoot<P, R, 'classes' | O> : P & {
-    /** className for `root` slot */
     className?: string;
 }) & ExtendAttributes;
-/**
- * make props work with classes key type and add `root`
- *
- * @example
- * ```tsx
- * type ClassesKeys = 'foo' | 'bar';
- *
- * type MyComponentProps = WithClassesProps<{ example: string }, ClassesKeys>
- *
- * const props: MyComponentProps;
- *
- * props.classes = 'root';
- * props.classes = 'bar';
- * props.classes = 'foo';
- * ```
- */
 export declare type WithClassesProps<P, C extends string> = P & ClassesProp<C>;
-/**
- * @deprecated use `WithClassesProps` instead, just rename
- */
 export declare type BaseOverridableProps<P, C extends string> = WithClassesProps<P, C>;
 export declare type OverridableProps<B, T extends ElementType> = B & {
-    /**
-     * The component used for the root node.
-     * Either a string to use a HTML element or a component.
-     */
     component?: T;
 } & Omit<ComponentPropsWithRef<T>, keyof B>;
 export declare type RefFromProps<P> = P extends {

package/src/typings/OverridableTypes.d.ts

@@ -1,43 +1,14 @@
-/**
- * This file copy from MUI
- *
- * https://github.com/mui/material-ui/blob/master/packages/mui-types/index.d.ts
- */
 import type React from 'react';
-/**
- * Remove properties `K` from `T`.
- * Distributive for union types.
- *
- * @internal
- */
 export declare type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;
-/**
- * A component whose root component can be controlled via a `component` prop.
- *
- * Adjusts valid props based on the type of `component`.
- */
 export interface OverridableComponent<M extends OverridableTypeMap> {
     <C extends React.ElementType>(props: {
-        /**
-         * The component used for the root node.
-         * Either a string to use a HTML element or a component.
-         */
         component: C;
     } & OverrideProps<M, C>): JSX.Element | null;
     (props: DefaultComponentProps<M>): JSX.Element | null;
     displayName?: string;
 }
-/**
- * Props of the component if `component={Component}` is used.
- */
 export declare type OverrideProps<M extends OverridableTypeMap, C extends React.ElementType> = (BaseProps<M> & DistributiveOmit<React.ComponentPropsWithRef<C>, keyof BaseProps<M>>);
-/**
- * Props if `component={Component}` is NOT used.
- */
 export declare type DefaultComponentProps<M extends OverridableTypeMap> = BaseProps<M> & DistributiveOmit<React.ComponentPropsWithRef<M['defaultComponent']>, keyof BaseProps<M>>;
-/**
- * Props defined on the component.
- */
 export declare type BaseProps<M extends OverridableTypeMap> = M['props'];
 export interface OverridableTypeMap {
     props: {};

package/src/typings/UnitMap.d.ts

@@ -1,27 +1,12 @@
-/**
- * @ignore
- *
- * fixed a map with unit key
- */
 export declare type UnitMap<T extends string | number | symbol, K = any> = {
     [key in T]: K;
 };
-/**
- * @ignore
- *
- * convert `classes` type to `classes map` type
- */
 export declare type ClassesMap<T extends {
     classes?: any;
 } | undefined, K = any> = Partial<UnitMap<Classes<T>, K>>;
 declare type ClassesReturn<T extends {
     classes?: any;
 } | undefined> = keyof NonNullable<NonNullable<T>['classes']>;
-/**
- * get type of `classes` prop
- *
- * @returns classes type of prop
- */
 export declare type Classes<T extends {
     classes?: any;
 } | undefined> = ClassesReturn<T>;

package/src/utils/ariaHideOutside.d.ts

@@ -1,9 +1 @@
-/**
- * Hides all elements in the DOM outside the given targets from screen readers using aria-hidden,
- * and returns a function to revert these changes. In addition, changes to the DOM are watched
- * and new elements outside the targets are automatically hidden.
- * @param targets - The elements that should remain visible.
- * @param root - Nothing will be hidden above this element.
- * @returns - A function to restore all hidden elements.
- */
 export declare const ariaHideOutside: (targets: Element[], root?: HTMLElement) => () => void;

package/src/utils/checkDefaultPrevented.d.ts

@@ -1,3 +1,2 @@
 import { SyntheticEvent } from 'react';
-/** check is that event preventDefault */
 export declare const checkDefaultPrevented: (fc: (e: SyntheticEvent, ...args: any[]) => void) => (e: SyntheticEvent, ...args: any[]) => void;

package/src/utils/classes/useClasses.d.ts

@@ -6,35 +6,6 @@ export declare type Cls<T extends {
 }> = (...classValues: Array<T['classes'] | GlobalStateClassesKey | {
     [key in T['classes'] | GlobalStateClassesKey]?: boolean | undefined | null;
 } | undefined | null | false>) => string;
-/**
- * Custom hook for generating CSS classes based on input parameters.
- *
- * pick class from object with prefix of object like `sui-${prefix}-${key}`
- *
- * `className` will be apply to the `cls('root')` class.
- *
- * camelCase will be used for the key in the inputClasses object.
- *
- * and apply to kebabCase in the class name.
- *
- * ```tsx
- * type BaseButtonClasses =
- *   | 'root'
- *   | 'content'
- *   | 'start-slot';
- *
- * const cls = useClasses<BaseButtonClasses>('button', {
- *    root: 'custom-button-root',
- *    content: 'custom-button-content',
- *    startSlot: 'custom-button-start-slot',
- * }, 'custom-root-class');
- *
- * <button className={cls('root')}>Button</button> // 'sui-button-root custom-button-root custom-root-class'
- * <button className={cls('content')}>Button</button> // 'sui-button-content custom-button-content'
- *
- * <button className={cls('start-slot')}>Button</button> // 'sui-button-start-slot custom-button-start-slot'
- * ```
- */
 export declare const useClasses: <T extends {
     name: string;
     classes: string;

package/src/utils/combineProps.d.ts

@@ -1,90 +1,2 @@
-/**
- * Combine props object together
- *
- * that will group className, classes together
- * function will auto combine together,
- * trigger order is `intoProps.someFn(e) => defaultProps.someFn(e)`
- *
- * @param baseProps base props you want to combine together
- * @param newProps want to combine in to props
- * @param coverPropKeys some prop key you want to cover, not combine when type is function, ex. `ComponentType`
- *
- *
- * @example
- * ```tsx
- * combineProps(
-    {
-      children: <A />,
-      value: '1',
-      className: 'a1',
-      classes: {
-        root: 'root1'
-      },
-      count: 1,
-      size: 'large',
-      onClick: fn1
-    },
-    {
-      children: <B />,
-      value: '2',
-      className: 'a2',
-      classes: {
-        root: 'root2'
-      },
-      count: 2,
-      size: undefined,
-      onClick: fn2
-    },
-  )
-  // output result:
-  {
-    children: <B />,
-    value: '2',
-    className: 'a1 a2',
-    classes: {
-      root: 'root1 root2'
-    },
-    count: 2,
-    size: 'large',
-    onClick: (e) => {
-      fn2(e);
-      fn1(e);
-    }
-  }
- * ```
- */
 export declare const combineProps: <T>(baseProps: T, newProps: T | Partial<T>, coverPropKeys?: (keyof T)[] | undefined) => NonNullable<T>;
-/**
- * Combine two classes
- *
- * @param baseClasses base classes you want to combine together
- * @param newClasses new classes want to combine in to props
- *
- * @example
- * ```ts
- * combineClasses(
-    {
-      root: 'a1',
-      input: 'a1',
-      un1: undefined,
-      un2: 'a4',
-    },
-    {
-      root: 'a1',
-      input: 'a2',
-      un1: 'a3',
-      un2: undefined,
-      un3: 'a5',
-    },
-  )
-  // output result:
-  {
-    root: 'a1 a1',
-    input: 'a1 a2',
-    un1: 'a3',
-    un2: 'a4',
-    un3: 'a5',
-  }
- * ```
- */
 export declare const combineClasses: <T>(baseClasses: T, newClasses: T | Partial<T>) => NonNullable<T>;

package/src/utils/getRefElement.d.ts

@@ -1,6 +1,3 @@
 import { MutableRefObject, RefObject } from 'react';
 export declare type RefOrElementOrCallback<T = HTMLElement> = RefObject<T> | (() => T) | T;
-/**
- * get element from React ref or callback
- */
 export declare const getRefElement: <T>(ref: T) => T extends () => infer R ? R : T extends RefObject<infer C> | MutableRefObject<infer C> ? C : T;

package/src/utils/isWebKit154.d.ts

@@ -1,9 +1 @@
-/**
- * Conditionally apply a workaround for the CSS transition bug in Safari 15.4 / WebKit browsers.
- * Remove this workaround once the WebKit bug fix is released.
- *
- * follow up:
- * https://github.com/mui/material-ui/pull/31975/files
- * https://github.com/mui/material-ui/pull/32202/files
- */
 export declare const isWebKit154: boolean;

package/src/utils/omit.d.ts

@@ -1,2 +1 @@
-/** enhance lodash type */
 export declare const omit: <T extends Record<string, unknown>, K extends (keyof T)[]>(classes: T | undefined, keys: K) => Partial<{ [K2 in Exclude<keyof T, K[number]>]: T[K2]; }>;

package/src/utils/outerSize.d.ts

@@ -1,7 +1,3 @@
-/**
- * get that full height and margin with margin
- * that will ignore transform animation
- */
 export declare function outerSize(el: HTMLElement): {
     readonly height: number;
     readonly width: number;

package/src/utils/pick.d.ts

@@ -1,2 +1 @@
-/** enhance lodash type */
 export declare const pick: <T extends Record<string, unknown>, K extends (keyof T)[]>(classes: T | undefined, keys: K) => { [K2 in Extract<keyof T, K[number]>]: T[K2]; };

package/src/utils/preloadImg.d.ts

@@ -1,2 +1 @@
-/** preload image file */
 export declare function preloadImg(url: string): Promise<void>;

package/src/utils/removeClassName.d.ts

@@ -1,35 +1,7 @@
 import { RefOrElementOrCallback } from './getRefElement';
 declare type RemoveClassNameOptions = {
-    /**
-     * make replace also scan child nodes
-     *
-     * @default false
-     */
     scanChildren?: boolean;
-    /**
-     * is that should fullMatch class name
-     *
-     * @default false
-     */
     fullMatch?: boolean;
 };
-/**
- * remove className from element, default will not scan child nodes, if you want to scan child nodes, set `scanChildren` to `true`.
- *
- * @param target target element reference or element or callback
- * @param removeClass className to remove, default will use class `includes` to check, if you want to use full match, set `fullMatch` to `true`
- *
- * @example
- * ```js
- * elm => <div class="abc bcd efg abc-def"></div>
- *
- * removeClassName(elmRef, 'bcd');
- *
- * elm => <div class="abc efg abc-def"></div>
- *
- * removeClassName(elmRef, 'abc');
- * elm => <div class="efg"></div>
- * ```
- */
 export declare function removeClassName(target: RefOrElementOrCallback, removeClass: string, { scanChildren, fullMatch }?: RemoveClassNameOptions): void;
 export {};

package/src/utils/runKeyHandler.d.ts

@@ -1,12 +1,4 @@
 import { KeyboardEvent } from 'react';
 declare type KeyHandlers = Record<KeyboardEvent['key'], () => void>;
-/**
- * Executes the corresponding key handler function based on the provided keyboard event.
- * If a handler is found for the pressed key, it will be invoked.
- * Additionally, it prevents any side effects caused by the event, such as page scrolling.
- *
- * @param e - The keyboard event.
- * @param keyHandlers - An object containing key-handler mappings.
- */
 export declare const runKeyHandler: (e: KeyboardEvent<unknown>, keyHandlers: KeyHandlers) => void;
 export {};

package/src/utils/selectionHandler.d.ts

@@ -1,7 +1,4 @@
 import { RefOrElementOrCallback } from './getRefElement';
-/**
- * get current input element selection position and is that selectRange state
- */
 export declare function getSelectionPosition<T extends HTMLInputElement | HTMLTextAreaElement>(sourceTarget: RefOrElementOrCallback<T>): {
     isSelectRange: boolean;
     position: {
@@ -9,15 +6,10 @@ export declare function getSelectionPosition<T extends HTMLInputElement | HTMLTe
         end: number;
     };
 };
-/**
- * set input element selection position position,
- * if you need scroll that into view set `scrollIntoView` as true
- */
 export declare function setSelectionPosition<T extends HTMLInputElement | HTMLTextAreaElement>(target: RefOrElementOrCallback<T>, options: {
     start: number | null;
     end: number | null;
     direction?: 'forward' | 'backward' | 'none' | undefined;
     scrollIntoView?: boolean;
 }): void;
-/** clean whole selection */
 export declare function clearWindowSelection(): void;

package/src/utils/twMerge.d.ts

@@ -1,4 +1 @@
-/**
- * Merge tailwind classes with additional class groups for spring-ui
- */
 export declare const twMerge: (...classLists: import("tailwind-merge").ClassNameValue[]) => string;