@nocobase/plugin-client 0.11.1-alpha.5 → 0.12.0-alpha.2

package/dist/locale/antd/skeleton/style/index.js

@@ -0,0 +1,311 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _cssinjs = require("@ant-design/cssinjs");
+var _internal = require("../../theme/internal");
+const skeletonClsLoading = new _cssinjs.Keyframes(`ant-skeleton-loading`, {
+  '0%': {
+    backgroundPosition: '100% 50%'
+  },
+  '100%': {
+    backgroundPosition: '0 50%'
+  }
+});
+const genSkeletonElementCommonSize = size => ({
+  height: size,
+  lineHeight: `${size}px`
+});
+const genSkeletonElementAvatarSize = size => Object.assign({
+  width: size
+}, genSkeletonElementCommonSize(size));
+const genSkeletonColor = token => ({
+  background: token.skeletonLoadingBackground,
+  backgroundSize: '400% 100%',
+  animationName: skeletonClsLoading,
+  animationDuration: token.skeletonLoadingMotionDuration,
+  animationTimingFunction: 'ease',
+  animationIterationCount: 'infinite'
+});
+const genSkeletonElementInputSize = size => Object.assign({
+  width: size * 5,
+  minWidth: size * 5
+}, genSkeletonElementCommonSize(size));
+const genSkeletonElementAvatar = token => {
+  const {
+    skeletonAvatarCls,
+    gradientFromColor,
+    controlHeight,
+    controlHeightLG,
+    controlHeightSM
+  } = token;
+  return {
+    [`${skeletonAvatarCls}`]: Object.assign({
+      display: 'inline-block',
+      verticalAlign: 'top',
+      background: gradientFromColor
+    }, genSkeletonElementAvatarSize(controlHeight)),
+    [`${skeletonAvatarCls}${skeletonAvatarCls}-circle`]: {
+      borderRadius: '50%'
+    },
+    [`${skeletonAvatarCls}${skeletonAvatarCls}-lg`]: Object.assign({}, genSkeletonElementAvatarSize(controlHeightLG)),
+    [`${skeletonAvatarCls}${skeletonAvatarCls}-sm`]: Object.assign({}, genSkeletonElementAvatarSize(controlHeightSM))
+  };
+};
+const genSkeletonElementInput = token => {
+  const {
+    controlHeight,
+    borderRadiusSM,
+    skeletonInputCls,
+    controlHeightLG,
+    controlHeightSM,
+    gradientFromColor
+  } = token;
+  return {
+    [`${skeletonInputCls}`]: Object.assign({
+      display: 'inline-block',
+      verticalAlign: 'top',
+      background: gradientFromColor,
+      borderRadius: borderRadiusSM
+    }, genSkeletonElementInputSize(controlHeight)),
+    [`${skeletonInputCls}-lg`]: Object.assign({}, genSkeletonElementInputSize(controlHeightLG)),
+    [`${skeletonInputCls}-sm`]: Object.assign({}, genSkeletonElementInputSize(controlHeightSM))
+  };
+};
+const genSkeletonElementImageSize = size => Object.assign({
+  width: size
+}, genSkeletonElementCommonSize(size));
+const genSkeletonElementImage = token => {
+  const {
+    skeletonImageCls,
+    imageSizeBase,
+    gradientFromColor,
+    borderRadiusSM
+  } = token;
+  return {
+    [`${skeletonImageCls}`]: Object.assign(Object.assign({
+      display: 'flex',
+      alignItems: 'center',
+      justifyContent: 'center',
+      verticalAlign: 'top',
+      background: gradientFromColor,
+      borderRadius: borderRadiusSM
+    }, genSkeletonElementImageSize(imageSizeBase * 2)), {
+      [`${skeletonImageCls}-path`]: {
+        fill: '#bfbfbf'
+      },
+      [`${skeletonImageCls}-svg`]: Object.assign(Object.assign({}, genSkeletonElementImageSize(imageSizeBase)), {
+        maxWidth: imageSizeBase * 4,
+        maxHeight: imageSizeBase * 4
+      }),
+      [`${skeletonImageCls}-svg${skeletonImageCls}-svg-circle`]: {
+        borderRadius: '50%'
+      }
+    }),
+    [`${skeletonImageCls}${skeletonImageCls}-circle`]: {
+      borderRadius: '50%'
+    }
+  };
+};
+const genSkeletonElementButtonShape = (token, size, buttonCls) => {
+  const {
+    skeletonButtonCls
+  } = token;
+  return {
+    [`${buttonCls}${skeletonButtonCls}-circle`]: {
+      width: size,
+      minWidth: size,
+      borderRadius: '50%'
+    },
+    [`${buttonCls}${skeletonButtonCls}-round`]: {
+      borderRadius: size
+    }
+  };
+};
+const genSkeletonElementButtonSize = size => Object.assign({
+  width: size * 2,
+  minWidth: size * 2
+}, genSkeletonElementCommonSize(size));
+const genSkeletonElementButton = token => {
+  const {
+    borderRadiusSM,
+    skeletonButtonCls,
+    controlHeight,
+    controlHeightLG,
+    controlHeightSM,
+    gradientFromColor
+  } = token;
+  return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({
+    [`${skeletonButtonCls}`]: Object.assign({
+      display: 'inline-block',
+      verticalAlign: 'top',
+      background: gradientFromColor,
+      borderRadius: borderRadiusSM,
+      width: controlHeight * 2,
+      minWidth: controlHeight * 2
+    }, genSkeletonElementButtonSize(controlHeight))
+  }, genSkeletonElementButtonShape(token, controlHeight, skeletonButtonCls)), {
+    [`${skeletonButtonCls}-lg`]: Object.assign({}, genSkeletonElementButtonSize(controlHeightLG))
+  }), genSkeletonElementButtonShape(token, controlHeightLG, `${skeletonButtonCls}-lg`)), {
+    [`${skeletonButtonCls}-sm`]: Object.assign({}, genSkeletonElementButtonSize(controlHeightSM))
+  }), genSkeletonElementButtonShape(token, controlHeightSM, `${skeletonButtonCls}-sm`));
+};
+// =============================== Base ===============================
+const genBaseStyle = token => {
+  const {
+    componentCls,
+    skeletonAvatarCls,
+    skeletonTitleCls,
+    skeletonParagraphCls,
+    skeletonButtonCls,
+    skeletonInputCls,
+    skeletonImageCls,
+    controlHeight,
+    controlHeightLG,
+    controlHeightSM,
+    gradientFromColor,
+    padding,
+    marginSM,
+    borderRadius,
+    titleHeight,
+    blockRadius,
+    paragraphLiHeight,
+    controlHeightXS,
+    paragraphMarginTop
+  } = token;
+  return {
+    [`${componentCls}`]: {
+      display: 'table',
+      width: '100%',
+      [`${componentCls}-header`]: {
+        display: 'table-cell',
+        paddingInlineEnd: padding,
+        verticalAlign: 'top',
+        // Avatar
+        [`${skeletonAvatarCls}`]: Object.assign({
+          display: 'inline-block',
+          verticalAlign: 'top',
+          background: gradientFromColor
+        }, genSkeletonElementAvatarSize(controlHeight)),
+        [`${skeletonAvatarCls}-circle`]: {
+          borderRadius: '50%'
+        },
+        [`${skeletonAvatarCls}-lg`]: Object.assign({}, genSkeletonElementAvatarSize(controlHeightLG)),
+        [`${skeletonAvatarCls}-sm`]: Object.assign({}, genSkeletonElementAvatarSize(controlHeightSM))
+      },
+      [`${componentCls}-content`]: {
+        display: 'table-cell',
+        width: '100%',
+        verticalAlign: 'top',
+        // Title
+        [`${skeletonTitleCls}`]: {
+          width: '100%',
+          height: titleHeight,
+          background: gradientFromColor,
+          borderRadius: blockRadius,
+          [`+ ${skeletonParagraphCls}`]: {
+            marginBlockStart: controlHeightSM
+          }
+        },
+        // paragraph
+        [`${skeletonParagraphCls}`]: {
+          padding: 0,
+          '> li': {
+            width: '100%',
+            height: paragraphLiHeight,
+            listStyle: 'none',
+            background: gradientFromColor,
+            borderRadius: blockRadius,
+            '+ li': {
+              marginBlockStart: controlHeightXS
+            }
+          }
+        },
+        [`${skeletonParagraphCls}> li:last-child:not(:first-child):not(:nth-child(2))`]: {
+          width: '61%'
+        }
+      },
+      [`&-round ${componentCls}-content`]: {
+        [`${skeletonTitleCls}, ${skeletonParagraphCls} > li`]: {
+          borderRadius
+        }
+      }
+    },
+    [`${componentCls}-with-avatar ${componentCls}-content`]: {
+      // Title
+      [`${skeletonTitleCls}`]: {
+        marginBlockStart: marginSM,
+        [`+ ${skeletonParagraphCls}`]: {
+          marginBlockStart: paragraphMarginTop
+        }
+      }
+    },
+    // Skeleton element
+    [`${componentCls}${componentCls}-element`]: Object.assign(Object.assign(Object.assign(Object.assign({
+      display: 'inline-block',
+      width: 'auto'
+    }, genSkeletonElementButton(token)), genSkeletonElementAvatar(token)), genSkeletonElementInput(token)), genSkeletonElementImage(token)),
+    // Skeleton Block Button, Input
+    [`${componentCls}${componentCls}-block`]: {
+      width: '100%',
+      [`${skeletonButtonCls}`]: {
+        width: '100%'
+      },
+      [`${skeletonInputCls}`]: {
+        width: '100%'
+      }
+    },
+    // With active animation
+    [`${componentCls}${componentCls}-active`]: {
+      [`
+        ${skeletonTitleCls},
+        ${skeletonParagraphCls} > li,
+        ${skeletonAvatarCls},
+        ${skeletonButtonCls},
+        ${skeletonInputCls},
+        ${skeletonImageCls}
+      `]: Object.assign({}, genSkeletonColor(token))
+    }
+  };
+};
+// ============================== Export ==============================
+var _default = (0, _internal.genComponentStyleHook)('Skeleton', token => {
+  const {
+    componentCls
+  } = token;
+  const skeletonToken = (0, _internal.mergeToken)(token, {
+    skeletonAvatarCls: `${componentCls}-avatar`,
+    skeletonTitleCls: `${componentCls}-title`,
+    skeletonParagraphCls: `${componentCls}-paragraph`,
+    skeletonButtonCls: `${componentCls}-button`,
+    skeletonInputCls: `${componentCls}-input`,
+    skeletonImageCls: `${componentCls}-image`,
+    imageSizeBase: token.controlHeight * 1.5,
+    borderRadius: 100,
+    skeletonLoadingBackground: `linear-gradient(90deg, ${token.gradientFromColor} 25%, ${token.gradientToColor} 37%, ${token.gradientFromColor} 63%)`,
+    skeletonLoadingMotionDuration: '1.4s'
+  });
+  return [genBaseStyle(skeletonToken)];
+}, token => {
+  const {
+    colorFillContent,
+    colorFill
+  } = token;
+  const gradientFromColor = colorFillContent;
+  const gradientToColor = colorFill;
+  return {
+    color: gradientFromColor,
+    colorGradientEnd: gradientToColor,
+    gradientFromColor,
+    gradientToColor,
+    titleHeight: token.controlHeight / 2,
+    blockRadius: token.borderRadiusSM,
+    paragraphMarginTop: token.marginLG + token.marginXXS,
+    paragraphLiHeight: token.controlHeight / 2
+  };
+}, {
+  deprecatedTokens: [['color', 'gradientFromColor'], ['colorGradientEnd', 'gradientToColor']]
+});
+exports.default = _default;

package/dist/locale/antd/slider/SliderTooltip.d.ts

@@ -0,0 +1,5 @@
+import type { SliderRef } from 'rc-slider/lib/Slider';
+import * as React from 'react';
+import type { TooltipProps } from '../tooltip';
+declare const SliderTooltip: React.ForwardRefExoticComponent<TooltipProps & React.RefAttributes<SliderRef>>;
+export default SliderTooltip;

package/dist/locale/antd/slider/SliderTooltip.js

@@ -0,0 +1,46 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _raf = _interopRequireDefault(require("rc-util/lib/raf"));
+var _ref = require("rc-util/lib/ref");
+var React = _interopRequireWildcard(require("react"));
+var _tooltip = _interopRequireDefault(require("../tooltip"));
+const SliderTooltip = /*#__PURE__*/React.forwardRef((props, ref) => {
+  const {
+    open
+  } = props;
+  const innerRef = (0, React.useRef)(null);
+  const rafRef = (0, React.useRef)(null);
+  function cancelKeepAlign() {
+    _raf.default.cancel(rafRef.current);
+    rafRef.current = null;
+  }
+  function keepAlign() {
+    rafRef.current = (0, _raf.default)(() => {
+      var _a;
+      (_a = innerRef.current) === null || _a === void 0 ? void 0 : _a.forceAlign();
+      rafRef.current = null;
+    });
+  }
+  React.useEffect(() => {
+    if (open) {
+      keepAlign();
+    } else {
+      cancelKeepAlign();
+    }
+    return cancelKeepAlign;
+  }, [open, props.title]);
+  return /*#__PURE__*/React.createElement(_tooltip.default, Object.assign({
+    ref: (0, _ref.composeRef)(innerRef, ref)
+  }, props));
+});
+if (process.env.NODE_ENV !== 'production') {
+  SliderTooltip.displayName = 'SliderTooltip';
+}
+var _default = SliderTooltip;
+exports.default = _default;

package/dist/locale/antd/slider/index.d.ts

@@ -0,0 +1,83 @@
+import type { SliderProps as RcSliderProps } from 'rc-slider';
+import type { SliderRef } from 'rc-slider/lib/Slider';
+import React from 'react';
+import type { TooltipPlacement } from '../tooltip';
+export type SliderMarks = RcSliderProps['marks'];
+interface HandleGeneratorInfo {
+    value?: number;
+    dragging?: boolean;
+    index: number;
+}
+export type HandleGeneratorFn = (config: {
+    tooltipPrefixCls?: string;
+    prefixCls?: string;
+    info: HandleGeneratorInfo;
+}) => React.ReactElement;
+export type Formatter = (value?: number) => React.ReactNode;
+export interface SliderTooltipProps {
+    prefixCls?: string;
+    open?: boolean;
+    placement?: TooltipPlacement;
+    getPopupContainer?: (triggerNode: HTMLElement) => HTMLElement;
+    formatter?: null | Formatter;
+}
+export interface SliderBaseProps {
+    prefixCls?: string;
+    reverse?: boolean;
+    min?: number;
+    max?: number;
+    step?: null | number;
+    marks?: SliderMarks;
+    dots?: boolean;
+    included?: boolean;
+    disabled?: boolean;
+    keyboard?: boolean;
+    vertical?: boolean;
+    className?: string;
+    rootClassName?: string;
+    id?: string;
+    style?: React.CSSProperties;
+    tooltip?: SliderTooltipProps;
+    autoFocus?: boolean;
+    /** @deprecated `tooltipPrefixCls` is deprecated. Please use `tooltip.prefixCls` instead. */
+    tooltipPrefixCls?: string;
+    /** @deprecated `tipFormatter` is deprecated. Please use `tooltip.formatter` instead. */
+    tipFormatter?: null | ((value?: number) => React.ReactNode);
+    /** @deprecated `tooltipVisible` is deprecated. Please use `tooltip.open` instead. */
+    tooltipVisible?: boolean;
+    /**
+     * @deprecated `getTooltipPopupContainer` is deprecated. Please use `tooltip.getPopupContainer`
+     *   instead.
+     */
+    getTooltipPopupContainer?: (triggerNode: HTMLElement) => HTMLElement;
+    /** @deprecated `tooltipPlacement` is deprecated. Please use `tooltip.placement` instead. */
+    tooltipPlacement?: TooltipPlacement;
+}
+export interface SliderSingleProps extends SliderBaseProps {
+    range?: false;
+    value?: number;
+    defaultValue?: number;
+    onChange?: (value: number) => void;
+    onAfterChange?: (value: number) => void;
+    handleStyle?: React.CSSProperties;
+    trackStyle?: React.CSSProperties;
+    railStyle?: React.CSSProperties;
+}
+export interface SliderRangeProps extends SliderBaseProps {
+    range: true | SliderRange;
+    value?: [number, number];
+    defaultValue?: [number, number];
+    onChange?: (value: [number, number]) => void;
+    onAfterChange?: (value: [number, number]) => void;
+    handleStyle?: React.CSSProperties[];
+    trackStyle?: React.CSSProperties[];
+    railStyle?: React.CSSProperties;
+}
+interface SliderRange {
+    draggableTrack?: boolean;
+}
+export type Opens = {
+    [index: number]: boolean;
+};
+declare const Slider: React.ForwardRefExoticComponent<(SliderSingleProps | SliderRangeProps) & React.RefAttributes<SliderRef>>;
+export default Slider;

package/dist/locale/antd/slider/index.js

@@ -0,0 +1,148 @@
+"use strict";
+'use client';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _classnames = _interopRequireDefault(require("classnames"));
+var _rcSlider = _interopRequireDefault(require("rc-slider"));
+var _react = _interopRequireDefault(require("react"));
+var _warning = _interopRequireDefault(require("../_util/warning"));
+var _configProvider = require("../config-provider");
+var _DisabledContext = _interopRequireDefault(require("../config-provider/DisabledContext"));
+var _SliderTooltip = _interopRequireDefault(require("./SliderTooltip"));
+var _style = _interopRequireDefault(require("./style"));
+var __rest = void 0 && (void 0).__rest || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+const defaultFormatter = val => typeof val === 'number' ? val.toString() : '';
+const Slider = /*#__PURE__*/_react.default.forwardRef((props, ref) => {
+  const {
+      prefixCls: customizePrefixCls,
+      range,
+      className,
+      rootClassName,
+      style,
+      disabled,
+      // Deprecated Props
+      tooltipPrefixCls: legacyTooltipPrefixCls,
+      tipFormatter: legacyTipFormatter,
+      tooltipVisible: legacyTooltipVisible,
+      getTooltipPopupContainer: legacyGetTooltipPopupContainer,
+      tooltipPlacement: legacyTooltipPlacement
+    } = props,
+    restProps = __rest(props, ["prefixCls", "range", "className", "rootClassName", "style", "disabled", "tooltipPrefixCls", "tipFormatter", "tooltipVisible", "getTooltipPopupContainer", "tooltipPlacement"]);
+  const {
+    direction,
+    slider,
+    getPrefixCls,
+    getPopupContainer
+  } = _react.default.useContext(_configProvider.ConfigContext);
+  const contextDisabled = _react.default.useContext(_DisabledContext.default);
+  const mergedDisabled = disabled !== null && disabled !== void 0 ? disabled : contextDisabled;
+  const [opens, setOpens] = _react.default.useState({});
+  const toggleTooltipOpen = (index, open) => {
+    setOpens(prev => Object.assign(Object.assign({}, prev), {
+      [index]: open
+    }));
+  };
+  const getTooltipPlacement = (placement, vertical) => {
+    if (placement) {
+      return placement;
+    }
+    if (!vertical) {
+      return 'top';
+    }
+    return direction === 'rtl' ? 'left' : 'right';
+  };
+  const prefixCls = getPrefixCls('slider', customizePrefixCls);
+  const [wrapSSR, hashId] = (0, _style.default)(prefixCls);
+  const cls = (0, _classnames.default)(className, slider === null || slider === void 0 ? void 0 : slider.className, rootClassName, {
+    [`${prefixCls}-rtl`]: direction === 'rtl'
+  }, hashId);
+  // make reverse default on rtl direction
+  if (direction === 'rtl' && !restProps.vertical) {
+    restProps.reverse = !restProps.reverse;
+  }
+  // Range config
+  const [mergedRange, draggableTrack] = _react.default.useMemo(() => {
+    if (!range) {
+      return [false];
+    }
+    return typeof range === 'object' ? [true, range.draggableTrack] : [true, false];
+  }, [range]);
+  // Warning for deprecated usage
+  if (process.env.NODE_ENV !== 'production') {
+    [['tooltipPrefixCls', 'prefixCls'], ['getTooltipPopupContainer', 'getPopupContainer'], ['tipFormatter', 'formatter'], ['tooltipPlacement', 'placement'], ['tooltipVisible', 'open']].forEach(_ref => {
+      let [deprecatedName, newName] = _ref;
+      process.env.NODE_ENV !== "production" ? (0, _warning.default)(!(deprecatedName in props), 'Slider', `\`${deprecatedName}\` is deprecated, please use \`tooltip.${newName}\` instead.`) : void 0;
+    });
+  }
+  const handleRender = (node, info) => {
+    var _a;
+    const {
+      index,
+      dragging
+    } = info;
+    const {
+      tooltip = {},
+      vertical
+    } = props;
+    const tooltipProps = Object.assign({}, tooltip);
+    const {
+      open: tooltipOpen,
+      placement: tooltipPlacement,
+      getPopupContainer: getTooltipPopupContainer,
+      prefixCls: customizeTooltipPrefixCls,
+      formatter: tipFormatter
+    } = tooltipProps;
+    let mergedTipFormatter;
+    if (tipFormatter || tipFormatter === null) {
+      mergedTipFormatter = tipFormatter;
+    } else if (legacyTipFormatter || legacyTipFormatter === null) {
+      mergedTipFormatter = legacyTipFormatter;
+    } else {
+      mergedTipFormatter = defaultFormatter;
+    }
+    const isTipFormatter = mergedTipFormatter ? opens[index] || dragging : false;
+    const open = (_a = tooltipOpen !== null && tooltipOpen !== void 0 ? tooltipOpen : legacyTooltipVisible) !== null && _a !== void 0 ? _a : tooltipOpen === undefined && isTipFormatter;
+    const passedProps = Object.assign(Object.assign({}, node.props), {
+      onMouseEnter: () => toggleTooltipOpen(index, true),
+      onMouseLeave: () => toggleTooltipOpen(index, false)
+    });
+    const tooltipPrefixCls = getPrefixCls('tooltip', customizeTooltipPrefixCls !== null && customizeTooltipPrefixCls !== void 0 ? customizeTooltipPrefixCls : legacyTooltipPrefixCls);
+    return /*#__PURE__*/_react.default.createElement(_SliderTooltip.default, {
+      prefixCls: tooltipPrefixCls,
+      title: mergedTipFormatter ? mergedTipFormatter(info.value) : '',
+      open: open,
+      placement: getTooltipPlacement(tooltipPlacement !== null && tooltipPlacement !== void 0 ? tooltipPlacement : legacyTooltipPlacement, vertical),
+      key: index,
+      overlayClassName: `${prefixCls}-tooltip`,
+      getPopupContainer: getTooltipPopupContainer || legacyGetTooltipPopupContainer || getPopupContainer
+    }, /*#__PURE__*/_react.default.cloneElement(node, passedProps));
+  };
+  const mergedStyle = Object.assign(Object.assign({}, slider === null || slider === void 0 ? void 0 : slider.style), style);
+  return wrapSSR( /*#__PURE__*/_react.default.createElement(_rcSlider.default, Object.assign({}, restProps, {
+    step: restProps.step,
+    range: mergedRange,
+    draggableTrack: draggableTrack,
+    className: cls,
+    style: mergedStyle,
+    disabled: mergedDisabled,
+    ref: ref,
+    prefixCls: prefixCls,
+    handleRender: handleRender
+  })));
+});
+if (process.env.NODE_ENV !== 'production') {
+  Slider.displayName = 'Slider';
+}
+var _default = Slider;
+exports.default = _default;

package/dist/locale/antd/slider/style/index.d.ts

@@ -0,0 +1,48 @@
+export interface ComponentToken {
+    /**
+     * @desc 滑动输入高度
+     * @descEN Height of slider
+     */
+    controlSize: number;
+    /**
+     * @desc 轨道高度
+     * @descEN Height of rail
+     */
+    railSize: number;
+    /**
+     * @desc 滑块尺寸
+     * @descEN Size of handle
+     */
+    handleSize: number;
+    /**
+     * @desc 滑块尺寸（悬浮态）
+     * @descEN Size of handle when hover
+     */
+    handleSizeHover: number;
+    /**
+     * @desc 滑块边框宽度
+     * @descEN Border width of handle
+     */
+    handleLineWidth: number;
+    /**
+     * @desc 滑块边框宽度（悬浮态）
+     * @descEN Border width of handle when hover
+     */
+    handleLineWidthHover: number;
+    /**
+     * @desc 滑块圆点尺寸
+     * @descEN Size of dot
+     */
+    dotSize: number;
+    railBg: string;
+    railHoverBg: string;
+    trackBg: string;
+    trackHoverBg: string;
+    handleColor: string;
+    handleActiveColor: string;
+    dotBorderColor: string;
+    dotActiveBorderColor: string;
+    trackBgDisabled: string;
+}
+declare const _default: (prefixCls: string) => import("../../theme/interface").UseComponentStyleResult;
+export default _default;