@unicom-cloud/ui 0.8.41

package/types/slider/hook/useInterval.d.ts

@@ -0,0 +1,24 @@
+import type { SliderProps } from '../../slider/interface';
+export interface IntervalConfig {
+    begin: number;
+    end: number;
+    width: number;
+    step: number;
+    beginOffset?: number;
+    endOffset?: number;
+}
+declare function useInterval(props: {
+    marks: SliderProps['marks'];
+    getIntervalConfig?: SliderProps['getIntervalConfig'];
+    min: number;
+    max: number;
+    onlyMarkValue: boolean;
+    step: number;
+}): {
+    intervalConfigs: IntervalConfig[];
+    markList: {
+        key: string;
+        content: any;
+    }[];
+};
+export default useInterval;

package/types/slider/hook/useLegalValue.d.ts

@@ -0,0 +1,15 @@
+import { IntervalConfig } from './useInterval';
+export default function useLegalValue(props: {
+    isRange: boolean;
+    min: number;
+    max: number;
+    onlyMarkValue: boolean;
+    step: number;
+    intervalConfigs: IntervalConfig[];
+    marks: object;
+}): {
+    getLegalRangeValue: (val: number | number[]) => any[];
+    getLegalValue: (val: any) => any;
+    isLegalValue: (val: any) => boolean;
+    getNextMarkValue: (value: number, type: 'addition' | 'subtraction') => any;
+};

package/types/slider/index.d.ts

@@ -0,0 +1,6 @@
+import './style';
+import React from 'react';
+import type { SliderProps } from './interface';
+declare const _default: React.MemoExoticComponent<React.ForwardRefExoticComponent<SliderProps & React.RefAttributes<unknown>>>;
+export default _default;
+export type { SliderProps };

package/types/slider/interface.d.ts

@@ -0,0 +1,32 @@
+import { CSSProperties, ReactNode } from 'react';
+import { InputNumberProps } from '../input-number';
+export type TooltipPosition = 'top' | 'tl' | 'tr' | 'bottom' | 'bl' | 'br' | 'left' | 'lt' | 'lb' | 'right' | 'rt' | 'rb';
+export interface SliderProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    tooltipVisible?: boolean;
+    tooltipPosition?: 'top' | 'tl' | 'tr' | 'bottom' | 'bl' | 'br' | 'left' | 'lt' | 'lb' | 'right' | 'rt' | 'rb';
+    disabled?: boolean;
+    min?: number;
+    max?: number;
+    range?: boolean | {
+        draggableBar: boolean;
+    };
+    step?: number;
+    showTicks?: boolean;
+    marks?: Record<number, ReactNode>;
+    getIntervalConfig?: (range: number[], index: number) => {
+        step?: number;
+        width?: number | string;
+    };
+    onlyMarkValue?: boolean;
+    defaultValue?: number | number[];
+    value?: number | number[];
+    vertical?: boolean;
+    showInput?: boolean | InputNumberProps | InputNumberProps[];
+    getTooltipContainer?: () => Element;
+    formatTooltip?: (value: number) => string | ReactNode;
+    reverse?: boolean;
+    onAfterChange?: (val: number | number[]) => void;
+    onChange?: (val: number | number[]) => void;
+}

package/types/slider/style/index.d.ts

@@ -0,0 +1,5 @@
+import '../../input-number/style/index.less';
+import '../../input/style';
+import '../../style/index.less';
+import '../../tooltip/style';
+import './index.less';

package/types/slider/util.d.ts

@@ -0,0 +1,11 @@
+import { IntervalConfig } from './hook/useInterval';
+export declare function getPrecision(val: any): number;
+export declare function formatPercent(val: any): string;
+export declare function getOffset(val: number | string, range?: number[]): any;
+export declare function valueInRange(val: number | string, range: number[]): boolean;
+export declare function isNotEmpty(val: any): any;
+export declare function rateToFloat(val: string | number): number | undefined;
+export declare function getIntervalOffset(val: any, intervalConfig: IntervalConfig[]): any;
+export declare function sortNumberArray(arr: number[]): number[];
+export declare function needSort(arr: number[]): boolean;
+export declare function findNearestIndex(value: number, array: number[]): [number, number];

package/types/space/index.d.ts

@@ -0,0 +1,5 @@
+import './style';
+import type { SpaceProps, SpaceSize } from './interface';
+declare const SpaceComponent: import("react").ForwardRefExoticComponent<SpaceProps & import("react").RefAttributes<unknown>>;
+export default SpaceComponent;
+export type { SpaceProps, SpaceSize };

package/types/space/interface.d.ts

@@ -0,0 +1,12 @@
+import { CSSProperties, ReactNode } from 'react';
+export type SpaceSize = 'mini' | 'small' | 'medium' | 'large' | number;
+export interface SpaceProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    align?: 'start' | 'end' | 'center' | 'baseline';
+    direction?: 'vertical' | 'horizontal';
+    size?: SpaceSize | SpaceSize[];
+    wrap?: boolean;
+    split?: ReactNode;
+    children?: ReactNode;
+}

package/types/space/style/index.d.ts

@@ -0,0 +1,2 @@
+import '../../style/index.less';
+import './index.less';

package/types/space/toArray.d.ts

@@ -0,0 +1 @@
+export default function toArray(children: any): never[];

package/types/speech-synthesis/index.d.ts

@@ -0,0 +1 @@
+export default function SpeechSynthesis(props: any): import("react/jsx-dev-runtime").JSX.Element | undefined;

package/types/spin/DotLoading.d.ts

@@ -0,0 +1,5 @@
+import { CSSProperties } from 'react';
+export interface DotProps {
+    size?: CSSProperties['fontSize'];
+}
+export default function DotLoading(props: DotProps): import("react/jsx-dev-runtime").JSX.Element;

package/types/spin/index.d.ts

@@ -0,0 +1,6 @@
+import './style';
+import React from 'react';
+import type { SpinProps } from './interface';
+declare const SpinComponent: React.ForwardRefExoticComponent<SpinProps & React.RefAttributes<unknown>>;
+export default SpinComponent;
+export type { SpinProps };

package/types/spin/interface.d.ts

@@ -0,0 +1,14 @@
+import { CSSProperties, ReactNode } from 'react';
+export interface SpinProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    children?: ReactNode;
+    loading?: boolean;
+    size?: number;
+    icon?: ReactNode;
+    element?: ReactNode;
+    tip?: string | ReactNode;
+    delay?: number;
+    dot?: boolean;
+    block?: boolean;
+}

package/types/spin/style/index.d.ts

@@ -0,0 +1,2 @@
+import '../../style/index.less';
+import './index.less';

package/types/statistic/Countdown.d.ts

@@ -0,0 +1,4 @@
+import type { CountdownProps } from './interface';
+declare const CountdownComponent: import("react").ForwardRefExoticComponent<CountdownProps & import("react").RefAttributes<unknown>>;
+export default CountdownComponent;
+export type { CountdownProps };

package/types/statistic/index.d.ts

@@ -0,0 +1,8 @@
+import './style';
+import Countdown from './Countdown';
+import type { StatisticProps } from './interface';
+declare const StatisticComponent: import("react").ForwardRefExoticComponent<StatisticProps & import("react").RefAttributes<unknown>> & {
+    Countdown: typeof Countdown;
+};
+export default StatisticComponent;
+export type { StatisticProps };

package/types/statistic/interface.d.ts

@@ -0,0 +1,33 @@
+import { Dayjs } from 'dayjs';
+import { CSSProperties, ReactNode } from 'react';
+export interface StatisticProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    styleValue?: CSSProperties;
+    styleDecimal?: CSSProperties;
+    title?: string | ReactNode;
+    value?: string | number | Dayjs;
+    precision?: number;
+    groupSeparator?: boolean;
+    prefix?: string | ReactNode;
+    suffix?: string | ReactNode;
+    extra?: ReactNode;
+    countUp?: boolean;
+    countFrom?: number;
+    countDuration?: number;
+    format?: string;
+    renderFormat?: (value: StatisticProps['value'], formattedValue: string) => ReactNode;
+    loading?: boolean;
+}
+export interface CountdownProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    styleValue?: CSSProperties;
+    title?: string | ReactNode;
+    value?: number | string | Date | Dayjs;
+    format?: string;
+    renderFormat?: (valueDiff: number, formattedDiff: string) => ReactNode;
+    onFinish?: () => void;
+    start?: boolean;
+    now?: number | string | Date | Dayjs;
+}

package/types/statistic/style/index.d.ts

@@ -0,0 +1,3 @@
+import '../../skeleton/style';
+import '../../style/index.less';
+import './index.less';

package/types/statistic/util.d.ts

@@ -0,0 +1 @@
+export declare function getDateString(millisecond: number, format: string): string;

package/types/steps/Step.d.ts

@@ -0,0 +1,4 @@
+import type { StepProps } from './interface';
+declare const StepComponent: import("react").ForwardRefExoticComponent<StepProps & import("react").RefAttributes<unknown>>;
+export default StepComponent;
+export type { StepProps };

package/types/steps/index.d.ts

@@ -0,0 +1,9 @@
+import './style';
+import React from 'react';
+import Step from './Step';
+import type { StepsProps } from './interface';
+declare const StepsComponent: React.ForwardRefExoticComponent<StepsProps & React.RefAttributes<unknown>> & {
+    Step: typeof Step;
+};
+export default StepsComponent;
+export type { StepsProps };

package/types/steps/interface.d.ts

@@ -0,0 +1,42 @@
+import { CSSProperties, ReactNode } from 'react';
+export interface StepsProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    type?: 'default' | 'arrow' | 'dot' | 'navigation';
+    size?: 'default' | 'small';
+    direction?: 'vertical' | 'horizontal';
+    labelPlacement?: 'horizontal' | 'vertical';
+    current?: number;
+    status?: 'wait' | 'process' | 'finish' | 'error';
+    customDot?: (IconDot: ReactNode, stepConfig: CustomDotRecord) => ReactNode;
+    onChange?: (current: number, id: any) => void;
+    lineless?: boolean;
+    children?: any;
+}
+export type CustomDotRecord = {
+    index: number;
+    status: string;
+    title: ReactNode;
+    description: ReactNode;
+};
+export interface StepProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    prefixCls?: string;
+    index?: number;
+    current?: number;
+    direction?: 'horizontal' | 'vertical';
+    nextStepError?: boolean;
+    icon?: ReactNode;
+    type?: 'default' | 'arrow' | 'dot' | 'navigation';
+    customDot?: (IconDot: ReactNode, stepConfig: CustomDotRecord) => ReactNode;
+    labelPlacement?: 'horizontal' | 'vertical';
+    lineless?: boolean;
+    onClick?: (index: number, id: any, e: any) => void;
+    onChange?: (index: number, id: any) => void;
+    id?: any;
+    title?: string | ReactNode;
+    description?: string | ReactNode;
+    status?: 'wait' | 'process' | 'finish' | 'error';
+    disabled?: boolean;
+}

package/types/steps/style/index.d.ts

@@ -0,0 +1,2 @@
+import '../../style/index.less';
+import './index.less';

package/types/suspense-fallback-test/index.d.ts

@@ -0,0 +1,3 @@
+declare const _default: React.ForwardRefExoticComponent<Omit<any, "ref"> & React.RefAttributes<any>>;
+export default _default;
+import React from 'react';

package/types/suspense-fallback-test/style/index.d.ts

@@ -0,0 +1,2 @@
+import '../../style/index.less';
+import './index.less';

package/types/switch/index.d.ts

@@ -0,0 +1,11 @@
+import './style';
+import React from 'react';
+import type { SwitchProps } from './interface';
+export interface SwitchState {
+    checked: boolean;
+}
+declare const SwitchComponent: React.ForwardRefExoticComponent<SwitchProps & React.RefAttributes<unknown>> & {
+    __PQB_SWITCH: boolean;
+};
+export default SwitchComponent;
+export type { SwitchProps };

package/types/switch/interface.d.ts

@@ -0,0 +1,17 @@
+import { CSSProperties, ReactNode, HTMLAttributes } from 'react';
+export interface SwitchProps extends Omit<HTMLAttributes<HTMLButtonElement>, 'className' | 'onChange'> {
+    style?: CSSProperties;
+    className?: string | string[];
+    disabled?: boolean;
+    onChange?: (value: boolean, event: any) => void;
+    size?: 'small' | 'default';
+    type?: 'circle' | 'round' | 'line';
+    checkedText?: ReactNode;
+    uncheckedText?: ReactNode;
+    uncheckedIcon?: ReactNode;
+    checkedIcon?: ReactNode;
+    defaultChecked?: boolean;
+    checked?: boolean;
+    loading?: boolean;
+    children?: ReactNode;
+}

package/types/switch/style/index.d.ts

@@ -0,0 +1,2 @@
+import '../../style/index.less';
+import './index.less';

package/types/table/ColGroup.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { InternalColumnProps } from './interface';
+type ColGroupType = {
+    prefixCls?: string;
+    columns?: InternalColumnProps[];
+    columnWidths?: number[];
+    producer?: boolean;
+    onSetColumnWidths?: (widths: number[]) => void;
+    expandedRowKeys?: React.Key[];
+    data?: any[];
+};
+declare function ColGroup(props: ColGroupType): import("react/jsx-dev-runtime").JSX.Element;
+export default ColGroup;

package/types/table/Table.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { TableProps } from './interface';
+export interface TableInstance {
+    getRootDomElement: () => HTMLDivElement;
+    scrollIntoView: (dataIndex: React.Key) => void;
+}
+declare const _default: <T>(props: TableProps<T> & {
+    ref?: React.Ref<TableInstance>;
+}) => React.ReactElement;
+export default _default;

package/types/table/constant.d.ts

@@ -0,0 +1,2 @@
+export declare const INTERNAL_SELECTION_KEY = "table_internal_selection_key";
+export declare const INTERNAL_EXPAND_KEY = "table_internal_expand_key";

package/types/table/hook/useColumns.d.ts

@@ -0,0 +1,3 @@
+import { InternalColumnProps, TableProps } from '../../table/interface';
+declare function useColumns<T>(props: TableProps<T>): [InternalColumnProps[][], InternalColumnProps[]];
+export default useColumns;

package/types/table/hook/useComponent.d.ts

@@ -0,0 +1,30 @@
+import { ComponentProps } from '../../table/interface';
+export default function useComponent(component: ComponentProps): {
+    getHeaderComponentOperations: ((nodes: {
+        selectionNode?: import("react").ReactNode;
+        expandNode?: import("react").ReactNode;
+    }) => {
+        name?: string | undefined;
+        node?: import("react").ReactNode;
+        width?: number | undefined;
+    }[]) | undefined;
+    getBodyComponentOperations: ((nodes: {
+        selectionNode?: import("react").ReactNode;
+        expandNode?: import("react").ReactNode;
+    }) => {
+        name?: string | undefined;
+        node?: import("react").ReactNode | ((record: any) => import("react").ReactNode);
+        width?: number | undefined;
+    }[]) | undefined;
+    ComponentTable: any;
+    ComponentHeaderWrapper: any;
+    ComponentThead: any;
+    ComponentHeaderRow: any;
+    ComponentTh: any;
+    ComponentHeaderCell: any;
+    ComponentBodyWrapper: any;
+    ComponentTbody: any;
+    ComponentBodyRow: any;
+    ComponentTd: any;
+    ComponentBodyCell: any;
+};

package/types/table/hook/useExpand.d.ts

@@ -0,0 +1,3 @@
+import { Key } from 'react';
+import { GetRowKeyType, TableProps } from '../../table/interface';
+export default function useExpand<T>(props: TableProps<T>, flattenData: any, getRowKey: GetRowKeyType<T>): [Key[], (key: Key) => void];

package/types/table/hook/useRowSelection.d.ts

@@ -0,0 +1,12 @@
+import React, { Key } from 'react';
+import { GetRowKeyType, TableProps } from '../../table/interface';
+export default function useRowSelection<T>(props: TableProps<T>, pageData: any, data: any, getRowKey: GetRowKeyType<T>): {
+    selectedRowKeys: Key[];
+    indeterminateKeys: Key[];
+    onCheckAll: (checked: any) => void;
+    onCheck: (checked: any, record: any) => void;
+    onCheckRadio: (key: any, record: any) => void;
+    setSelectedRowKeys: React.Dispatch<React.SetStateAction<Key[]>>;
+    allSelectedRowKeys: Key[];
+    flattenData: T[];
+};

package/types/table/hook/useSorter.d.ts

@@ -0,0 +1,7 @@
+import { SorterInfo } from '../interface';
+export default function useSorter(flattenColumns: any, defaultSorters: any): {
+    currentSorter: SorterInfo;
+    activeSorters: SorterInfo[];
+    getNextActiveSorters: (sorter: SorterInfo) => SorterInfo[];
+    updateStateSorters: (sorter: SorterInfo, nextActiveSorters: SorterInfo[]) => void;
+};

package/types/table/hook/useStickyClassNames.d.ts

@@ -0,0 +1,3 @@
+import { InternalColumnProps } from '../../table/interface';
+declare function useStickyClassNames(groupColumns: InternalColumnProps[][], columns: InternalColumnProps[], prefixCls: string): [string[][], string[]];
+export default useStickyClassNames;

package/types/table/hook/useStickyOffsets.d.ts

@@ -0,0 +1,3 @@
+import { InternalColumnProps } from '../../table/interface';
+declare function useStickyOffsets(columns: InternalColumnProps[]): number[];
+export default useStickyOffsets;

package/types/table/index.d.ts

@@ -0,0 +1,9 @@
+import './style';
+import Summary from './summary';
+declare const TableComponent: (<T>(props: import("./interface").TableProps<T> & {
+    ref?: import("react").Ref<import("./Table").TableInstance> | undefined;
+}) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>) & {
+    Summary: typeof Summary;
+};
+export default TableComponent;
+export type { ColumnProps, ExpandProps, RowSelectionProps, TableProps, } from './interface';