@unicom-cloud/ui 0.8.114 → 0.8.116

package/types/_common/transition-group/Transition.d.ts

@@ -0,0 +1,130 @@
+import React from 'react';
+export declare const UNMOUNTED = "unmounted";
+export declare const EXITED = "exited";
+export declare const ENTERING = "entering";
+export declare const ENTERED = "entered";
+export declare const EXITING = "exiting";
+/**
+ * The Transition component lets you describe a transition from one component
+ * state to another _over time_ with a simple declarative API. Most commonly
+ * it's used to animate the mounting and unmounting of a component, but can also
+ * be used to describe in-place transition states as well.
+ *
+ * ---
+ *
+ * **Note**: `Transition` is a platform-agnostic base component. If you're using
+ * transitions in CSS, you'll probably want to use
+ * [`CSSTransition`](https://reactcommunity.org/react-transition-group/css-transition)
+ * instead. It inherits all the features of `Transition`, but contains
+ * additional features necessary to play nice with CSS transitions (hence the
+ * name of the component).
+ *
+ * ---
+ *
+ * By default the `Transition` component does not alter the behavior of the
+ * component it renders, it only tracks "enter" and "exit" states for the
+ * components. It's up to you to give meaning and effect to those states. For
+ * example we can add styles to a component when it enters or exits:
+ *
+ * ```jsx
+ * import { Transition } from 'react-transition-group';
+ * import { useRef } from 'react';
+ *
+ * const duration = 300;
+ *
+ * const defaultStyle = {
+ *   transition: `opacity ${duration}ms ease-in-out`,
+ *   opacity: 0,
+ * }
+ *
+ * const transitionStyles = {
+ *   entering: { opacity: 1 },
+ *   entered:  { opacity: 1 },
+ *   exiting:  { opacity: 0 },
+ *   exited:  { opacity: 0 },
+ * };
+ *
+ * function Fade({ in: inProp }) {
+ *   const refElement = useRef(null);
+ *   return (
+ *     <Transition refElement={refElement} in={inProp} timeout={duration}>
+ *       {state => (
+ *         <div ref={refElement} style={{
+ *           ...defaultStyle,
+ *           ...transitionStyles[state]
+ *         }}>
+ *           I'm a fade Transition!
+ *         </div>
+ *       )}
+ *     </Transition>
+ *   );
+ * }
+ * ```
+ *
+ * There are 4 main states a Transition can be in:
+ *  - `'entering'`
+ *  - `'entered'`
+ *  - `'exiting'`
+ *  - `'exited'`
+ *
+ * Transition state is toggled via the `in` prop. When `true` the component
+ * begins the "Enter" stage. During this stage, the component will shift from
+ * its current transition state, to `'entering'` for the duration of the
+ * transition and then to the `'entered'` stage once it's complete. Let's take
+ * the following example (we'll use the
+ * [useState](https://reactjs.org/docs/hooks-reference.html#usestate) hook):
+ *
+ * ```jsx
+ * import { Transition } from 'react-transition-group';
+ * import { useState, useRef } from 'react';
+ *
+ * function App() {
+ *   const [inProp, setInProp] = useState(false);
+ *   const refElement = useRef(null);
+ *   return (
+ *     <div>
+ *       <Transition refElement={refElement} in={inProp} timeout={500}>
+ *         {state => ()}
+ *       </Transition>
+ *       <button onClick={() => setInProp(true)}>
+ *         Click to Enter
+ *       </button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * When the button is clicked the component will shift to the `'entering'` state
+ * and stay there for 500ms (the value of `timeout`) before it finally switches
+ * to `'entered'`.
+ *
+ * When `in` is `false` the same thing happens except the state moves from
+ * `'exiting'` to `'exited'`.
+ */
+declare class Transition extends React.Component {
+    static contextType: React.Context<null>;
+    constructor(props: any, context: any);
+    refElement: undefined;
+    static getDerivedStateFromProps({ in: nextIn }: {
+        in: any;
+    }, prevState: any): {
+        status: string;
+    } | null;
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: any): void;
+    componentWillUnmount(): void;
+    getTimeouts(): {
+        exit: any;
+        enter: any;
+        appear: any;
+    };
+    updateStatus(mounting: boolean | undefined, nextStatus: any): void;
+    performEnter(mounting: any): void;
+    performExit(): void;
+    cancelNextCallback(): void;
+    safeSetState(nextState: any, callback: any): void;
+    setNextCallback(callback: any): any;
+    onTransitionEnd(timeout: any, handler: any): void;
+    render(): React.JSX.Element | null;
+}
+export default Transition;

package/types/_common/transition-group/TransitionGroup.d.ts

@@ -0,0 +1,31 @@
+import React from 'react';
+/**
+ * The `<TransitionGroup>` component manages a set of transition components
+ * (`<Transition>` and `<CSSTransition>`) in a list. Like with the transition
+ * components, `<TransitionGroup>` is a state machine for managing the mounting
+ * and unmounting of components over time.
+ *
+ * Consider the example below. As items are removed or added to the TodoList the
+ * `in` prop is toggled automatically by the `<TransitionGroup>`.
+ *
+ * Note that `<TransitionGroup>`  does not define any animation behavior!
+ * Exactly _how_ a list item animates is up to the individual transition
+ * component. This means you can mix and match animations across different list
+ * items.
+ */
+declare class TransitionGroup extends React.Component {
+    constructor(props: any, context: any);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    static getDerivedStateFromProps(nextProps: any, { children: prevChildMapping, handleExited, firstRender }: {
+        children: any;
+        handleExited: any;
+        firstRender: any;
+    }): {
+        children: object;
+        firstRender: boolean;
+    };
+    handleExited(child: any, element: any): void;
+    render(): React.JSX.Element;
+}
+export default TransitionGroup;

package/types/_common/transition-group/TransitionGroupContext.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const _default: React.Context<null>;
+export default _default;

package/types/_common/transition-group/index.d.ts

@@ -0,0 +1,10 @@
+export { default as CSSTransition } from './CSSTransition';
+export { default as PqbCSSTransition } from './PqbCSSTransition';
+export { default as ReplaceTransition } from './ReplaceTransition';
+export { default as SwitchTransition, modes as SwitchTransitionModes, } from './SwitchTransition';
+export { default as Transition, ENTERED as TRANSITION_ENTERED, ENTERING as TRANSITION_ENTERING, EXITED as TRANSITION_EXITED, EXITING as TRANSITION_EXITING, UNMOUNTED as TRANSITION_UNMOUNTED, } from './Transition';
+export { default as TransitionGroup } from './TransitionGroup';
+export { default as TransitionGroupContext } from './TransitionGroupContext';
+export { getChildMapping as TransitionGroupGetChildMapping, getInitialChildMapping as TransitionGroupGetInitialChildMapping, getNextChildMapping as TransitionGroupGetNextChildMapping, mergeChildMappings as TransitionGroupMergeChildMappings, } from './utils/ChildMapping';
+export { forceReflow as TransitionGroupForceReflow } from './utils/reflow';
+export { default } from './TransitionGroup';

package/types/_common/transition-group/utils/ChildMapping.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Given `this.props.children`, return an object mapping key to child.
+ *
+ * @param {*} children `this.props.children`
+ * @return {object} Mapping of key to child
+ */
+export function getChildMapping(children: any, mapFn: any): object;
+/**
+ * When you're adding or removing children some may be added or removed in the
+ * same render pass. We want to show *both* since we want to simultaneously
+ * animate elements in and out. This function takes a previous set of keys
+ * and a new set of keys and merges them with its best guess of the correct
+ * ordering. In the future we may expose some of the utilities in
+ * ReactMultiChild to make this easy, but for now React itself does not
+ * directly have this concept of the union of prevChildren and nextChildren
+ * so we implement it here.
+ *
+ * @param {object} prev prev children as returned from
+ * `ReactTransitionChildMapping.getChildMapping()`.
+ * @param {object} next next children as returned from
+ * `ReactTransitionChildMapping.getChildMapping()`.
+ * @return {object} a key set that contains all keys in `prev` and all keys
+ * in `next` in a reasonable order.
+ */
+export function mergeChildMappings(prev: object, next: object): object;
+export function getInitialChildMapping(props: any, onExited: any): object;
+export function getNextChildMapping(nextProps: any, prevChildMapping: any, onExited: any): object;

package/types/_common/transition-group/utils/reflow.d.ts

@@ -0,0 +1,3 @@
+export { forceReflow };
+export default forceReflow;
+import forceReflow from '@unicom-cloud/utils/types/dom-helpers/reflow';

package/types/_common/utils/caseName.d.ts

@@ -0,0 +1,2 @@
+export { default as caseName, default } from '@unicom-cloud/utils/types/case-name';
+export type * from '@unicom-cloud/utils/types/types/case-name';

package/types/_common/utils/className.d.ts

@@ -0,0 +1,2 @@
+export { default as className, default } from '@unicom-cloud/utils/types/class-name';
+export type * from '@unicom-cloud/utils/types/types/class-name';

package/types/_common/utils/constant.d.ts

@@ -0,0 +1,3 @@
+export declare const CSS_VARIABLE_ELEMENT: HTMLElement;
+export declare const NOOP: () => void;
+export { UI_PC_KEY, UI_PC_THEME_DARK_CLASS_NAME, } from '@unicom-cloud/utils/types/constant/ui';

package/types/_common/utils/copy.d.ts

@@ -0,0 +1,4 @@
+import copy from '@unicom-cloud/utils/types/clipboard-copy';
+export { copy as clipboardCopy, copy };
+export default copy;
+export type * from '@unicom-cloud/utils/types/types/clipboard-copy';

package/types/_common/utils/date.d.ts

@@ -0,0 +1,2 @@
+export * from '@unicom-cloud/utils/types/date';
+export type * from '@unicom-cloud/utils/types/types/date';

package/types/_common/utils/dom.d.ts

@@ -0,0 +1,25 @@
+export declare const isServerRendering: boolean;
+export declare const on: (element: EventTarget | null, event: string, handler: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void;
+export declare const off: (element: EventTarget | null, event: string, handler: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void;
+export declare const contains: (root: HTMLElement, ele: any) => boolean;
+export declare function isScrollElement(element: HTMLElement): boolean;
+/**
+ * 从当前节点向上查找所有的滚动元素
+ * @param container 当前节点
+ * @param top 查找到 top 节点就终止，不再继续查找
+ * @returns
+ */
+export declare const getScrollElements: (container: HTMLElement, top?: HTMLElement) => HTMLElement[];
+/**
+ * 判断父节点是否包含子节点
+ * @desc {en} confirm parentNode contains children nodes
+ * @param {HTMLElement | null} parentEl 父节点
+ * @param {HTMLElement | null} parentEl {en} The parent element
+ * @param {HTMLElement | null} childrenEl 子节点
+ * @param {HTMLElement | null} childrenEl {en} The child element
+ * @returns {boolean} 是否包含子节点
+ * @returns {boolean} {en} Whether the parent contains the child
+ * @example
+ */
+export declare function parentContainsChildren(parentEl: HTMLElement | null, childrenEl: HTMLElement | null): boolean;
+export declare function getBodyContainer(): HTMLElement;

package/types/_common/utils/emitter.d.ts

@@ -0,0 +1,2 @@
+export { default, default as emitter } from '@unicom-cloud/utils/types/emitter';
+export type * from '@unicom-cloud/utils/types/types/emitter';

package/types/_common/utils/fileToURL.d.ts

@@ -0,0 +1,2 @@
+export { default, default as fileToURL } from '@unicom-cloud/utils/types/file/fileToURL';
+export type * from '@unicom-cloud/utils/types/types/file/fileToURL';

package/types/_common/utils/findScrollParent.d.ts

@@ -0,0 +1,2 @@
+declare function findScrollParent(element: any, includeHidden?: boolean): any;
+export default findScrollParent;

package/types/_common/utils/index.d.ts

@@ -0,0 +1,45 @@
+export * from './caseName';
+export * from './className';
+export * from './constant';
+export * from './copy';
+export * from './date';
+export * from './dayjs';
+export * from './dom';
+export * from './emitter';
+export * from './fileToURL';
+export * from './fillNBSP';
+export * from './findScrollParent';
+export * from './getHighlightText';
+export * from './getHotkeyHandler';
+export * from './getStringLength';
+export * from './include';
+export * from './intersectionObserver';
+export * from './is';
+export * from './lodash';
+export * from './math';
+export * from './mergedToString';
+export * from './mergeProps';
+export * from './mutationObserver';
+export * from './omit';
+export * from './pad';
+export * from './pick';
+export * from './pinyin';
+export * from './reactDOM';
+export * from './resizeObserver';
+export * from './saveAs';
+export * from './screenfull';
+export * from './scrollIntoViewIfNeeded';
+export * from './setDarkTheme';
+export * from './setDir';
+export * from './setPrimaryColor';
+export * from './setTheme';
+export * from './style';
+export * from './throttleByRaf';
+export * from './tinycolor';
+export * from './toArray';
+export * from './tree';
+export * from './tween';
+export * from './uuid';
+export * from './validate';
+export * from './warning';
+export { keyboardCode } from './keyboardCode';

package/types/_common/utils/intersectionObserver.d.ts

@@ -0,0 +1,3 @@
+declare function intersectionObserver(elements: any, callback: any): () => void;
+export { intersectionObserver };
+export default intersectionObserver;

package/types/_common/utils/is.d.ts

@@ -0,0 +1,16 @@
+import { isArguments, isArray, isArrayBuffer, isArrayLike, isArrayLikeObject, isBlob, isBoolean, isBuffer, isColor, isColor2, isDate, isElement, isEmpty, isEmptyArray, isEmptyObject, isEmptyValue, isEqual, isEqualWith, isError, isFile, isFinite, isFunction, isInteger, isJSON, isLength, isMap, isMatch, isMatchWith, isNaN, isNative, isNil, isNull, isNumber, isObject, isObjectLike, isPlainObject, isPromise, isReadableByteStreamControllerSupported, isReadableStream, isReadableStreamDefaultControllerSupported, isReadableStreamSupported, isReadableStreamSymbolAsyncIteratorSupported, isRegExp, isSafeInteger, isSet, isString, isSymbol, isTypedArray, isUndefined, isValidColor, isWeakMap, isWeakSet } from '@unicom-cloud/utils/types/is';
+import { isDayjs } from 'dayjs';
+import { isContextConsumer as isReactContextConsumer, isContextProvider as isReactContextProvider, isElement as isReactElement, isForwardRef as isReactForwardRef, isFragment as isReactFragment, isLazy as isReactLazy, isMemo as isReactMemo, isPortal as isReactPortal, isProfiler as isReactProfiler, isStrictMode as isReactStrictMode, isSuspense as isReactSuspense, isValidElementType as isReactValidElementType } from 'react-is';
+declare function isNullOrUndefined(obj: any): boolean;
+declare function isEmptyReactNode(content: any, trim?: boolean): boolean;
+declare function isExist(obj: any): boolean;
+declare function isWindow(el: any): el is Window;
+declare const isReactComponent: (element: any) => boolean;
+declare const isClassComponent: (element: any) => boolean;
+declare const isDOMElement: (element: any) => boolean;
+declare const isReact18: boolean;
+declare const isReact19: boolean;
+declare const isForwardRefReact: (object: any) => boolean;
+declare function supportRef(element: any): boolean;
+declare function is32Bit(c: string): boolean | 0 | undefined;
+export { is32Bit, isArguments, isArray, isArrayBuffer, isArrayLike, isArrayLikeObject, isBlob, isBoolean, isBuffer, isClassComponent, isColor, isColor2, isDate, isDayjs, isDOMElement, isElement, isEmpty, isEmptyArray, isEmptyObject, isEmptyReactNode, isEmptyValue, isEqual, isEqualWith, isError, isExist, isFile, isFinite, isForwardRefReact, isFunction, isInteger, isJSON, isLength, isMap, isMatch, isMatchWith, isNaN, isNative, isNil, isNull, isNullOrUndefined, isNumber, isObject, isObjectLike, isPlainObject, isPromise, isReact18, isReact19, isReactComponent, isReactContextConsumer, isReactContextProvider, isReactElement, isReactForwardRef, isReactFragment, isReactLazy, isReactMemo, isReactPortal, isReactProfiler, isReactStrictMode, isReactSuspense, isReactValidElementType, isReadableByteStreamControllerSupported, isReadableStream, isReadableStreamDefaultControllerSupported, isReadableStreamSupported, isReadableStreamSymbolAsyncIteratorSupported, isRegExp, isSafeInteger, isSet, isString, isSymbol, isTypedArray, isUndefined, isValidColor, isWeakMap, isWeakSet, isWindow, supportRef, };

package/types/_common/utils/keyboardCode.d.ts

@@ -0,0 +1,5 @@
+import * as keyboardCode from '@unicom-cloud/utils/types/constant/keyboardCode';
+export * from '@unicom-cloud/utils/types/constant/keyboardCode';
+export type * from '@unicom-cloud/utils/types/types/constant/keyboardCode';
+export { keyboardCode };
+export default keyboardCode;

package/types/_common/utils/lodash.d.ts

@@ -0,0 +1,60 @@
+import assign from 'lodash/assign';
+import assignIn from 'lodash/assignIn';
+import at from 'lodash/at';
+import camelCase from 'lodash/camelCase';
+import capitalize from 'lodash/capitalize';
+import castArray from 'lodash/castArray';
+import chain from 'lodash/chain';
+import chunk from 'lodash/chunk';
+import clone from 'lodash/clone';
+import cloneDeep from 'lodash/cloneDeep';
+import cloneDeepWith from 'lodash/cloneDeepWith';
+import cloneWith from 'lodash/cloneWith';
+import compact from 'lodash/compact';
+import curry from 'lodash/curry';
+import debounce from 'lodash/debounce';
+import defaults from 'lodash/defaults';
+import defaultsDeep from 'lodash/defaultsDeep';
+import defaultTo from 'lodash/defaultTo';
+import difference from 'lodash/difference';
+import escape from 'lodash/escape';
+import findKey from 'lodash/findKey';
+import flattenDeep from 'lodash/flattenDeep';
+import flow from 'lodash/flow';
+import get from 'lodash/get';
+import groupBy from 'lodash/groupBy';
+import has from 'lodash/has';
+import intersection from 'lodash/intersection';
+import invert from 'lodash/invert';
+import invertBy from 'lodash/invertBy';
+import kebabCase from 'lodash/kebabCase';
+import mean from 'lodash/mean';
+import memoize from 'lodash/memoize';
+import merge from 'lodash/merge';
+import mergeWith from 'lodash/mergeWith';
+import orderBy from 'lodash/orderBy';
+import partition from 'lodash/partition';
+import pullAll from 'lodash/pullAll';
+import result from 'lodash/result';
+import sample from 'lodash/sample';
+import sampleSize from 'lodash/sampleSize';
+import set from 'lodash/set';
+import setWith from 'lodash/setWith';
+import shuffle from 'lodash/shuffle';
+import snakeCase from 'lodash/snakeCase';
+import startCase from 'lodash/startCase';
+import throttle from 'lodash/throttle';
+import toPath from 'lodash/toPath';
+import truncate from 'lodash/truncate';
+import union from 'lodash/union';
+import uniq from 'lodash/uniq';
+import uniqueId from 'lodash/uniqueId';
+import unset from 'lodash/unset';
+import update from 'lodash/update';
+import updateWith from 'lodash/updateWith';
+import upperCase from 'lodash/upperCase';
+import upperFirst from 'lodash/upperFirst';
+import without from 'lodash/without';
+import xor from 'lodash/xor';
+import zip from 'lodash/zip';
+export { assign, assignIn, at, camelCase, capitalize, castArray, chain, chunk, clone, cloneDeep, cloneDeepWith, cloneWith, compact, curry, debounce, defaults, defaultsDeep, defaultTo, difference, escape, findKey, flattenDeep, flow, get, groupBy, has, intersection, invert, invertBy, kebabCase, mean, memoize, merge, mergeWith, orderBy, partition, pullAll, result, sample, sampleSize, set, setWith, shuffle, snakeCase, startCase, throttle, toPath, truncate, union, uniq, uniqueId, unset, update, updateWith, upperCase, upperFirst, without, xor, zip, };

package/types/_common/utils/math.d.ts

@@ -0,0 +1,2 @@
+export { default, div, default as math, minus, plus, times, } from '@unicom-cloud/utils/types/math';
+export type * from '@unicom-cloud/utils/types/types/math';

package/types/_common/utils/mutationObserver.d.ts

@@ -0,0 +1,3 @@
+declare function mutationObserver(elements: any, callback: any): () => void;
+export { mutationObserver };
+export default mutationObserver;

package/types/_common/utils/pick.d.ts

@@ -0,0 +1,6 @@
+declare function pick<T extends object, K extends keyof T>(o: T, keys: Array<K | string>): Pick<T, K>;
+declare function pickDataAttributes<T extends object, K extends keyof T>(o: T | undefined): {
+    [key in K]: unknown;
+};
+export { pick, pickDataAttributes };
+export default pick;

package/types/_common/utils/pinyin.d.ts

@@ -0,0 +1,2 @@
+export { default, default as pinyin } from '@unicom-cloud/utils/types/pinyin';
+export type * from '@unicom-cloud/utils/types/types/pinyin';

package/types/_common/utils/reactDOM.d.ts

@@ -0,0 +1,34 @@
+import { ReactElement, ReactInstance, RefObject } from 'react';
+type CreateRootFnType = (container: Element | DocumentFragment) => {
+    render: (element: ReactElement) => void;
+    unmount: () => void;
+};
+type RenderResult = {
+    render: (element: ReactElement) => void;
+    _unmount: () => void;
+};
+type ElementLike = {
+    dom?: Element;
+    current?: Element;
+    props?: {
+        ref?: RefObject<Element> | ((instance: Element | null) => void);
+    };
+    ref?: RefObject<Element> | ((instance: Element | null) => void);
+    getRootDOMNode?: () => Element | null;
+};
+/**
+ *
+ * @param element
+ * @param instance 兜底 findDOMNode 查找，一般都是 this
+ * @returns
+ */
+export declare function findDOMNode(element: ElementLike, instance?: ReactInstance): Element | null;
+export declare function callbackOriginRef(children: {
+    ref?: RefObject<Element> | ((instance: Element | null) => void);
+    props?: {
+        ref?: RefObject<Element> | ((instance: Element | null) => void);
+    };
+} | null, node: Element | null): void;
+export declare function setCreateRoot(v: CreateRootFnType): void;
+export declare function render(node: ReactElement, el: Element | DocumentFragment): RenderResult;
+export {};

package/types/_common/utils/saveAs.d.ts

@@ -0,0 +1,2 @@
+export { default, default as saveAs } from '@unicom-cloud/utils/types/file/saveAs';
+export type * from '@unicom-cloud/utils/types/types/file/saveAs';

package/types/_common/utils/screenfull.d.ts

@@ -0,0 +1,2 @@
+export { default, default as screenfull } from '@unicom-cloud/utils/types/screenfull';
+export type * from '@unicom-cloud/utils/types/types/screenfull';

package/types/_common/utils/scrollIntoViewIfNeeded.d.ts

@@ -0,0 +1,69 @@
+export type ScrollBehavior = 'auto' | 'smooth';
+export type ScrollLogicalPosition = 'start' | 'center' | 'end' | 'nearest';
+/**
+ * 滚动模式类型
+ * - 'always'：总是执行滚动
+ * - 'if-needed'：仅当元素不可见时滚动
+ */
+export type ScrollMode = 'always' | 'if-needed';
+export type SkipOverflowHiddenElements = boolean;
+export type CustomScrollBoundaryCallback = (parent: Element) => boolean;
+export type CustomScrollBoundary = Element | CustomScrollBoundaryCallback | null;
+export interface CustomScrollAction {
+    el: Element;
+    top: number;
+    left: number;
+}
+export type CustomScrollBehaviorCallback<T = unknown> = (actions: CustomScrollAction[]) => T;
+export interface BaseOptions {
+    block?: ScrollLogicalPosition;
+    inline?: ScrollLogicalPosition;
+    scrollMode?: ScrollMode;
+    boundary?: CustomScrollBoundary;
+    skipOverflowHiddenElements?: SkipOverflowHiddenElements;
+}
+export interface StandardBehaviorOptions extends BaseOptions {
+    behavior?: ScrollBehavior;
+}
+export interface CustomBehaviorOptions<T = unknown> extends BaseOptions {
+    behavior: CustomScrollBehaviorCallback<T>;
+}
+export type Options<T = unknown> = StandardBehaviorOptions | CustomBehaviorOptions<T>;
+export interface SmoothScrollExtensions {
+    duration?: number;
+    ease?: (t: number) => number;
+    onScrollChange?: (state: {
+        target: Element;
+        elapsed: number;
+        value: number;
+        left: number;
+        top: number;
+    }) => void;
+}
+export interface SmoothBehaviorOptions extends StandardBehaviorOptions, SmoothScrollExtensions {
+    behavior?: 'smooth';
+}
+export interface StandardBehaviorOptions extends BaseOptions {
+    behavior?: ScrollBehavior;
+}
+export interface CustomBehaviorOptions<T = unknown> extends BaseOptions {
+    behavior: CustomScrollBehaviorCallback<T>;
+}
+/**
+ * 滚动动作描述
+ */
+export interface ScrollAction {
+    el: Element;
+    top: number;
+    left: number;
+}
+/**
+ * 计算需要执行的滚动动作
+ * @param target 目标元素
+ * @param options 滚动选项
+ */
+declare const compute: (target: Element, options: Options) => ScrollAction[];
+declare function scrollIntoViewNative(target: Element, options?: boolean | ScrollIntoViewOptions): void;
+declare function scrollIntoViewIfNeeded(node: HTMLElement, options?: Options): void;
+export { compute, scrollIntoViewIfNeeded, scrollIntoViewNative };
+export default scrollIntoViewIfNeeded;

package/types/_common/utils/setDarkTheme.d.ts

@@ -0,0 +1,4 @@
+declare function setDarkTheme(params: any): () => void;
+declare function removeDarkTheme(params: any): void;
+export { removeDarkTheme, setDarkTheme };
+export default setDarkTheme;

package/types/_common/utils/setDir.d.ts

@@ -0,0 +1,3 @@
+declare function setDir(params: any): void;
+export { setDir };
+export default setDir;

package/types/_common/utils/setPrimaryColor.d.ts

@@ -0,0 +1,3 @@
+declare function setPrimaryColor(params: any): () => void;
+export { setPrimaryColor };
+export default setPrimaryColor;

package/types/_common/utils/setTheme.d.ts

@@ -0,0 +1,3 @@
+declare function setTheme(params: any): void;
+export { setTheme };
+export default setTheme;

package/types/_common/utils/throttleByRaf2.d.ts

@@ -0,0 +1,6 @@
+declare function throttleByRaf2(cb: (...args: any[]) => void): {
+    (...args: unknown[]): number;
+    cancel(): void;
+};
+export { throttleByRaf2 };
+export default throttleByRaf2;

package/types/_common/utils/tinycolor.d.ts

@@ -0,0 +1,3 @@
+export * from '@unicom-cloud/utils/types/tinycolor';
+export { default, default as tinycolor } from '@unicom-cloud/utils/types/tinycolor';
+export type * from '@unicom-cloud/utils/types/types/tinycolor';

package/types/_common/utils/tree.d.ts

@@ -0,0 +1,2 @@
+export { default, findNodeBy, getChildWithParentBy, getItemBy, getItemBy2, getItemBy3, getItemByID, getLabelFromDictionaryByValue, searchTree, default as tree, } from '@unicom-cloud/utils/types/tree';
+export type * from '@unicom-cloud/utils/types/types/tree';

package/types/_common/utils/tween.d.ts

@@ -0,0 +1,2 @@
+export { default, easing, default as Tween } from '@unicom-cloud/tween';
+export type * from '@unicom-cloud/tween/types';

package/types/_common/utils/validate.d.ts

@@ -0,0 +1,2 @@
+export { ArrayValidator, BooleanValidator, CustomValidator, defaultValidateLocale, DefaultValidateMessage, enUSValidateLocale, mergeTemplate, NumberValidator, ObjectValidator, Schema, StringValidator, TypeValidator, default as validate, zhCNValidateLocale, } from '@unicom-cloud/validate';
+export type * from '@unicom-cloud/validate/types';

package/types/anchor/index.d.ts

@@ -0,0 +1,5 @@
+import Anchor, { AnchorLink } from './Anchor';
+import { findNode } from './utils';
+export { AnchorLink, findNode as findAnchorLinkNode };
+export default Anchor;
+export type { AnchorProps } from './interface';