@aloudata/aloudata-design 1.9.16 → 1.10.0

package/dist/Tree/utils/dictUtil.js

@@ -0,0 +1,74 @@
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+var Record = /*#__PURE__*/function (Record) {
+  Record[Record["None"] = 0] = "None";
+  Record[Record["Start"] = 1] = "Start";
+  Record[Record["End"] = 2] = "End";
+  return Record;
+}(Record || {});
+function traverseNodesKey(treeData, callback) {
+  function processNode(dataNode) {
+    var key = dataNode.key,
+      children = dataNode.children;
+    if (callback(key, dataNode) !== false) {
+      traverseNodesKey(children || [], callback);
+    }
+  }
+  treeData.forEach(processNode);
+}
+
+/** 计算选中范围，只考虑expanded情况以优化性能 */
+export function calcRangeKeys(_ref) {
+  var treeData = _ref.treeData,
+    expandedKeys = _ref.expandedKeys,
+    startKey = _ref.startKey,
+    endKey = _ref.endKey;
+  var keys = [];
+  var record = Record.None;
+  if (startKey && startKey === endKey) {
+    return [startKey];
+  }
+  if (!startKey || !endKey) {
+    return [];
+  }
+  function matchKey(key) {
+    return key === startKey || key === endKey;
+  }
+  traverseNodesKey(treeData, function (key) {
+    if (record === Record.End) {
+      return false;
+    }
+    if (matchKey(key)) {
+      // Match test
+      keys.push(key);
+      if (record === Record.None) {
+        record = Record.Start;
+      } else if (record === Record.Start) {
+        record = Record.End;
+        return false;
+      }
+    } else if (record === Record.Start) {
+      // Append selection
+      keys.push(key);
+    }
+    return expandedKeys.includes(key);
+  });
+  return keys;
+}
+export function convertDirectoryKeysToNodes(treeData, keys) {
+  var restKeys = _toConsumableArray(keys);
+  var nodes = [];
+  traverseNodesKey(treeData, function (key, node) {
+    var index = restKeys.indexOf(key);
+    if (index !== -1) {
+      nodes.push(node);
+      restKeys.splice(index, 1);
+    }
+    return !!restKeys.length;
+  });
+  return nodes;
+}

package/dist/Tree/utils/dropIndicator.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+export declare const offset = 4;
+export default function dropIndicatorRender(props: {
+    dropPosition: -1 | 0 | 1;
+    dropLevelOffset: number;
+    indent: number;
+    prefixCls: string;
+    direction: 'ltr' | 'rtl';
+}): React.JSX.Element;

package/dist/Tree/utils/dropIndicator.js

@@ -0,0 +1,35 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+import React from 'react';
+export var offset = 4;
+export default function dropIndicatorRender(props) {
+  var _style;
+  var dropPosition = props.dropPosition,
+    dropLevelOffset = props.dropLevelOffset,
+    prefixCls = props.prefixCls,
+    indent = props.indent,
+    _props$direction = props.direction,
+    direction = _props$direction === void 0 ? 'ltr' : _props$direction;
+  var startPosition = direction === 'ltr' ? 'left' : 'right';
+  var endPosition = direction === 'ltr' ? 'right' : 'left';
+  var style = (_style = {}, _defineProperty(_style, startPosition, -dropLevelOffset * indent + offset), _defineProperty(_style, endPosition, 0), _style);
+  switch (dropPosition) {
+    case -1:
+      style.top = -3;
+      break;
+    case 1:
+      style.bottom = -3;
+      break;
+    default:
+      // dropPosition === 0
+      style.bottom = -3;
+      style[startPosition] = indent + offset;
+      break;
+  }
+  return /*#__PURE__*/React.createElement("div", {
+    style: style,
+    className: "".concat(prefixCls, "-drop-indicator")
+  });
+}

package/dist/Tree/utils/iconUtil.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+import type { AldTreeNodeProps, SwitcherIcon, TreeLeafIcon } from '../Tree';
+export default function renderSwitcherIcon(prefixCls: string, switcherIcon: SwitcherIcon, showLine: boolean | {
+    showLeafIcon: boolean | TreeLeafIcon;
+} | undefined, treeNodeProps: AldTreeNodeProps): React.ReactNode;

package/dist/Tree/utils/iconUtil.js

@@ -0,0 +1,63 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+import CaretDownFilled from '@ant-design/icons/CaretDownFilled';
+import FileOutlined from '@ant-design/icons/FileOutlined';
+import LoadingOutlined from '@ant-design/icons/LoadingOutlined';
+import MinusSquareOutlined from '@ant-design/icons/MinusSquareOutlined';
+import PlusSquareOutlined from '@ant-design/icons/PlusSquareOutlined';
+import classNames from 'classnames';
+import * as React from 'react';
+import { cloneElement, isValidElement } from "../../_utils/reactNode";
+export default function renderSwitcherIcon(prefixCls, switcherIcon, showLine, treeNodeProps) {
+  var isLeaf = treeNodeProps.isLeaf,
+    expanded = treeNodeProps.expanded,
+    loading = treeNodeProps.loading;
+  if (loading) {
+    return /*#__PURE__*/React.createElement(LoadingOutlined, {
+      className: "".concat(prefixCls, "-switcher-loading-icon")
+    });
+  }
+  var showLeafIcon;
+  if (showLine && _typeof(showLine) === 'object') {
+    showLeafIcon = showLine.showLeafIcon;
+  }
+  if (isLeaf) {
+    if (!showLine) {
+      return null;
+    }
+    if (typeof showLeafIcon !== 'boolean' && !!showLeafIcon) {
+      var leafIcon = typeof showLeafIcon === 'function' ? showLeafIcon(treeNodeProps) : showLeafIcon;
+      var leafCls = "".concat(prefixCls, "-switcher-line-custom-icon");
+      if (isValidElement(leafIcon)) {
+        return cloneElement(leafIcon, {
+          className: classNames(leafIcon.props.className || '', leafCls)
+        });
+      }
+      return leafIcon;
+    }
+    return showLeafIcon ? /*#__PURE__*/React.createElement(FileOutlined, {
+      className: "".concat(prefixCls, "-switcher-line-icon")
+    }) : /*#__PURE__*/React.createElement("span", {
+      className: "".concat(prefixCls, "-switcher-leaf-line")
+    });
+  }
+  var switcherCls = "".concat(prefixCls, "-switcher-icon");
+  var switcher = typeof switcherIcon === 'function' ? switcherIcon(treeNodeProps) : switcherIcon;
+  if (isValidElement(switcher)) {
+    return cloneElement(switcher, {
+      className: classNames(switcher.props.className || '', switcherCls)
+    });
+  }
+  if (switcher) {
+    return switcher;
+  }
+  if (showLine) {
+    return expanded ? /*#__PURE__*/React.createElement(MinusSquareOutlined, {
+      className: "".concat(prefixCls, "-switcher-line-icon")
+    }) : /*#__PURE__*/React.createElement(PlusSquareOutlined, {
+      className: "".concat(prefixCls, "-switcher-line-icon")
+    });
+  }
+  return /*#__PURE__*/React.createElement(CaretDownFilled, {
+    className: switcherCls
+  });
+}

package/dist/_utils/motion.d.ts

@@ -0,0 +1,8 @@
+import type { CSSMotionProps } from 'rc-motion';
+declare const collapseMotion: CSSMotionProps;
+declare const SelectPlacements: ["bottomLeft", "bottomRight", "topLeft", "topRight"];
+export type SelectCommonPlacement = (typeof SelectPlacements)[number];
+declare const getTransitionDirection: (placement: SelectCommonPlacement | undefined) => "slide-down" | "slide-up";
+declare const getTransitionName: (rootPrefixCls: string, motion: string, transitionName?: string) => string;
+export { getTransitionName, getTransitionDirection };
+export default collapseMotion;

package/dist/_utils/motion.js

@@ -0,0 +1,52 @@
+import { tuple } from "./type";
+
+// ================== Collapse Motion ==================
+var getCollapsedHeight = function getCollapsedHeight() {
+  return {
+    height: 0,
+    opacity: 0
+  };
+};
+var getRealHeight = function getRealHeight(node) {
+  var scrollHeight = node.scrollHeight;
+  return {
+    height: scrollHeight,
+    opacity: 1
+  };
+};
+var getCurrentHeight = function getCurrentHeight(node) {
+  return {
+    height: node ? node.offsetHeight : 0
+  };
+};
+var skipOpacityTransition = function skipOpacityTransition(_, event) {
+  return (event === null || event === void 0 ? void 0 : event.deadline) === true || event.propertyName === 'height';
+};
+var collapseMotion = {
+  motionName: 'ant-motion-collapse',
+  onAppearStart: getCollapsedHeight,
+  onEnterStart: getCollapsedHeight,
+  onAppearActive: getRealHeight,
+  onEnterActive: getRealHeight,
+  onLeaveStart: getCurrentHeight,
+  onLeaveActive: getCollapsedHeight,
+  onAppearEnd: skipOpacityTransition,
+  onEnterEnd: skipOpacityTransition,
+  onLeaveEnd: skipOpacityTransition,
+  motionDeadline: 500
+};
+var SelectPlacements = tuple('bottomLeft', 'bottomRight', 'topLeft', 'topRight');
+var getTransitionDirection = function getTransitionDirection(placement) {
+  if (placement !== undefined && (placement === 'topLeft' || placement === 'topRight')) {
+    return "slide-down";
+  }
+  return "slide-up";
+};
+var getTransitionName = function getTransitionName(rootPrefixCls, motion, transitionName) {
+  if (transitionName !== undefined) {
+    return transitionName;
+  }
+  return "".concat(rootPrefixCls, "-").concat(motion);
+};
+export { getTransitionName, getTransitionDirection };
+export default collapseMotion;

package/dist/_utils/reactNode.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+export declare const isValidElement: typeof React.isValidElement;
+export declare function isFragment(child: any): boolean;
+type AnyObject = Record<PropertyKey, any>;
+type RenderProps = AnyObject | ((originProps: AnyObject) => AnyObject | void);
+export declare function replaceElement(element: React.ReactNode, replacement: React.ReactNode, props?: RenderProps): React.ReactNode;
+export declare function cloneElement(element: React.ReactNode, props?: RenderProps): React.ReactElement;
+export {};

package/dist/_utils/reactNode.js

@@ -0,0 +1,15 @@
+import * as React from 'react';
+var isValidElement = React.isValidElement;
+export { isValidElement };
+export function isFragment(child) {
+  return child && isValidElement(child) && child.type === React.Fragment;
+}
+export function replaceElement(element, replacement, props) {
+  if (!isValidElement(element)) {
+    return replacement;
+  }
+  return /*#__PURE__*/React.cloneElement(element, typeof props === 'function' ? props(element.props || {}) : props);
+}
+export function cloneElement(element, props) {
+  return replaceElement(element, element, props);
+}

package/dist/_utils/type.d.ts

@@ -0,0 +1,9 @@
+export declare const tuple: <T extends string[]>(...args: T) => T;
+export declare const tupleNum: <T extends number[]>(...args: T) => T;
+/**
+ * https://stackoverflow.com/a/59187769 Extract the type of an element of an array/tuple without
+ * performing indexing
+ */
+export type ElementOf<T> = T extends (infer E)[] ? E : T extends readonly (infer F)[] ? F : never;
+/** https://github.com/Microsoft/TypeScript/issues/29729 */
+export type LiteralUnion<T extends U, U> = T | (U & object);

package/dist/_utils/type.js

@@ -0,0 +1,20 @@
+// https://stackoverflow.com/questions/46176165/ways-to-get-string-literal-type-of-array-values-without-enum-overhead
+export var tuple = function tuple() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+  return args;
+};
+export var tupleNum = function tupleNum() {
+  for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    args[_key2] = arguments[_key2];
+  }
+  return args;
+};
+
+/**
+ * https://stackoverflow.com/a/59187769 Extract the type of an element of an array/tuple without
+ * performing indexing
+ */
+
+/** https://github.com/Microsoft/TypeScript/issues/29729 */

package/dist/index.d.ts

@@ -1,16 +1,14 @@
 export type { MenuClickEventHandler } from 'rc-menu/lib/interface';
-export { default as AldTable } from './AldTable';
-export type { ITableColumn, ITableProps as IAldTableProps, } from './AldTable/types';
+export { default as AProgress } from './AProgress';
 export { default as Alert } from './Alert';
 export type { AlertProps } from './Alert';
 export { default as App } from './App';
-export { default as AProgress } from './AProgress';
 export { default as Avatar } from './Avatar';
 export type { IAvatarProps as AvatarProps } from './Avatar';
 export { default as Breadcrumb } from './Breadcrumb';
 export type { BreadcrumbItemProps, BreadcrumbProps } from './Breadcrumb';
 export { default as Button } from './Button';
-export type { ButtonType, IButtonProps as ButtonProps } from './Button';
+export type { IButtonProps as ButtonProps, ButtonType } from './Button';
 export { default as Card } from './Card';
 export type { CardProps } from './Card';
 export { default as Carousel } from './Carousel';
@@ -25,7 +23,7 @@ export { default as ColorPicker } from './ColorPicker';
 export type { IColorPickerProps } from './ColorPicker';
 export { default as ConfigProvider } from './ConfigProvider';
 export { default as DataPreviewTable } from './DataPreviewTable';
-export type { DataPreviewTableRef, ITableProps as DataPreviewTableProps, PreviewColumn, } from './DataPreviewTable/interface';
+export type { ITableProps as DataPreviewTableProps, DataPreviewTableRef, PreviewColumn, } from './DataPreviewTable/interface';
 export { default as DatePicker } from './DatePicker';
 export type { DatePickerProps } from './DatePicker';
 export { default as Divider } from './Divider';
@@ -41,22 +39,19 @@ export type { FormInstance, FormItemProps, FormProps } from './Form';
 export { default as Icon } from './Icon';
 export { default as IconButton } from './IconButton';
 export { default as Input } from './Input';
-export type { IInputProps as InputProps, InputRef, TextAreaRef, TSize, } from './Input';
+export type { IInputProps as InputProps, InputRef, TSize, TextAreaRef, } from './Input';
 export { default as InputNumber } from './InputNumber';
 export type { IInputNumberProps as InputNumberProps } from './InputNumber';
 export { default as Layout } from './Layout';
 export type { LayoutProps } from './Layout';
 export { default as MemberPicker } from './MemberPicker';
-export type { IMemberPickerProps as MemberPickerProps, IUser, MemberPickerValue, } from './MemberPicker/interface';
+export type { IUser, IMemberPickerProps as MemberPickerProps, MemberPickerValue, } from './MemberPicker/interface';
 export { default as Menu } from './Menu';
-export type { IMenuProps as MenuProps, ItemType } from './Menu';
-export { default as message } from './message';
-export type { MessageArgsProps } from './message';
+export type { ItemType, IMenuProps as MenuProps } from './Menu';
 export { default as Modal } from './Modal';
 export type { ModalFuncProps, ModalProps } from './Modal';
 export { default as Navigator } from './Navigator';
 export type { IMenuItem as NavigatorMenu, INavigatorProps as NavigatorProps, ISelectedMenuInfo as SelectedMenuInfo, } from './Navigator';
-export { default as notification } from './notification';
 export { default as Pagination } from './Pagination';
 export { default as Popconfirm } from './Popconfirm';
 export type { PopconfirmProps } from './Popconfirm';
@@ -83,7 +78,7 @@ export type { IStepProps as StepProps, IStepsProps as StepsProps, } from './Step
 export { default as Switch } from './Switch';
 export type { ISwitchProps as SwitchProps } from './Switch';
 export { default as Table } from './Table';
-export type { IColumn, ISort, ITableProps, TSortOrder, } from './Table/interface';
+export type { ITableColumn, ITableProps } from './Table/types';
 export { default as Tabs } from './Tabs';
 export type { ITabsProps as TabsProps, TabsSize } from './Tabs';
 export { default as Tag } from './Tag';
@@ -91,8 +86,11 @@ export type { TagProps, TagType } from './Tag';
 export { default as Tooltip } from './Tooltip';
 export type { ActionType as TooltipActionType, ITooltipProps as TooltipProps, } from './Tooltip';
 export { default as Tree } from './Tree';
-export type { AntTreeNodeProps as TreeNodeProps, DataNode as TreeDataNode, TreeProps, } from './Tree';
+export type { DataNode as TreeDataNode, AldTreeNodeProps as TreeNodeProps, TreeProps, } from './Tree';
 export { default as Typography } from './Typography';
 export type { TypographyProps } from './Typography';
 export { default as Upload } from './Upload';
 export type { UploadFile, UploadProps } from './Upload';
+export { default as message } from './message';
+export type { MessageArgsProps } from './message';
+export { default as notification } from './notification';

package/dist/index.js

@@ -1,9 +1,8 @@
 // / <reference path="../typings.d.ts" />
 
-export { default as AldTable } from "./AldTable";
+export { default as AProgress } from "./AProgress";
 export { default as Alert } from "./Alert";
 export { default as App } from "./App";
-export { default as AProgress } from "./AProgress";
 export { default as Avatar } from "./Avatar";
 export { default as Breadcrumb } from "./Breadcrumb";
 export { default as Button } from "./Button";
@@ -28,12 +27,8 @@ export { default as InputNumber } from "./InputNumber";
 export { default as Layout } from "./Layout";
 export { default as MemberPicker } from "./MemberPicker";
 export { default as Menu } from "./Menu";
-export { default as message } from "./message";
-// alias, keep API the same as antd
-
 export { default as Modal } from "./Modal";
 export { default as Navigator } from "./Navigator";
-export { default as notification } from "./notification";
 export { default as Pagination } from "./Pagination";
 export { default as Popconfirm } from "./Popconfirm";
 export { default as Popover } from "./Popover";
@@ -54,4 +49,8 @@ export { default as Tag } from "./Tag";
 export { default as Tooltip } from "./Tooltip";
 export { default as Tree } from "./Tree";
 export { default as Typography } from "./Typography";
-export { default as Upload } from "./Upload";
+export { default as Upload } from "./Upload";
+export { default as message } from "./message";
+// alias, keep API the same as antd
+
+export { default as notification } from "./notification";

package/dist/style/color/bezierEasing.less

@@ -0,0 +1,110 @@
+/* stylelint-disable */
+.bezierEasingMixin() {
+@functions: ~`(function() {
+  var NEWTON_ITERATIONS = 4;
+  var NEWTON_MIN_SLOPE = 0.001;
+  var SUBDIVISION_PRECISION = 0.0000001;
+  var SUBDIVISION_MAX_ITERATIONS = 10;
+
+  var kSplineTableSize = 11;
+  var kSampleStepSize = 1.0 / (kSplineTableSize - 1.0);
+
+  var float32ArraySupported = typeof Float32Array === 'function';
+
+  function A (aA1, aA2) { return 1.0 - 3.0 * aA2 + 3.0 * aA1; }
+  function B (aA1, aA2) { return 3.0 * aA2 - 6.0 * aA1; }
+  function C (aA1)      { return 3.0 * aA1; }
+
+  // Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.
+  function calcBezier (aT, aA1, aA2) { return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT; }
+
+  // Returns dx/dt given t, x1, and x2, or dy/dt given t, y1, and y2.
+  function getSlope (aT, aA1, aA2) { return 3.0 * A(aA1, aA2) * aT * aT + 2.0 * B(aA1, aA2) * aT + C(aA1); }
+
+  function binarySubdivide (aX, aA, aB, mX1, mX2) {
+    var currentX, currentT, i = 0;
+    do {
+      currentT = aA + (aB - aA) / 2.0;
+      currentX = calcBezier(currentT, mX1, mX2) - aX;
+      if (currentX > 0.0) {
+        aB = currentT;
+      } else {
+        aA = currentT;
+      }
+    } while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);
+    return currentT;
+  }
+
+  function newtonRaphsonIterate (aX, aGuessT, mX1, mX2) {
+   for (var i = 0; i < NEWTON_ITERATIONS; ++i) {
+     var currentSlope = getSlope(aGuessT, mX1, mX2);
+     if (currentSlope === 0.0) {
+       return aGuessT;
+     }
+     var currentX = calcBezier(aGuessT, mX1, mX2) - aX;
+     aGuessT -= currentX / currentSlope;
+   }
+   return aGuessT;
+  }
+
+  var BezierEasing = function (mX1, mY1, mX2, mY2) {
+    if (!(0 <= mX1 && mX1 <= 1 && 0 <= mX2 && mX2 <= 1)) {
+      throw new Error('bezier x values must be in [0, 1] range');
+    }
+
+    // Precompute samples table
+    var sampleValues = float32ArraySupported ? new Float32Array(kSplineTableSize) : new Array(kSplineTableSize);
+    if (mX1 !== mY1 || mX2 !== mY2) {
+      for (var i = 0; i < kSplineTableSize; ++i) {
+        sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);
+      }
+    }
+
+    function getTForX (aX) {
+      var intervalStart = 0.0;
+      var currentSample = 1;
+      var lastSample = kSplineTableSize - 1;
+
+      for (; currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) {
+        intervalStart += kSampleStepSize;
+      }
+      --currentSample;
+
+      // Interpolate to provide an initial guess for t
+      var dist = (aX - sampleValues[currentSample]) / (sampleValues[currentSample + 1] - sampleValues[currentSample]);
+      var guessForT = intervalStart + dist * kSampleStepSize;
+
+      var initialSlope = getSlope(guessForT, mX1, mX2);
+      if (initialSlope >= NEWTON_MIN_SLOPE) {
+        return newtonRaphsonIterate(aX, guessForT, mX1, mX2);
+      } else if (initialSlope === 0.0) {
+        return guessForT;
+      } else {
+        return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);
+      }
+    }
+
+    return function BezierEasing (x) {
+      if (mX1 === mY1 && mX2 === mY2) {
+        return x; // linear
+      }
+      // Because JavaScript number are imprecise, we should guarantee the extremes are right.
+      if (x === 0) {
+        return 0;
+      }
+      if (x === 1) {
+        return 1;
+      }
+      return calcBezier(getTForX(x), mY1, mY2);
+    };
+  };
+
+  this.colorEasing = BezierEasing(0.26, 0.09, 0.37, 0.18);
+  // less 3 requires a return
+  return '';
+})()`;
+}
+// It is hacky way to make this function will be compiled preferentially by less
+// resolve error: `ReferenceError: colorPalette is not defined`
+// https://github.com/ant-design/ant-motion/issues/44
+.bezierEasingMixin();

package/dist/style/color/colorPalette.less

@@ -0,0 +1,84 @@
+/* stylelint-disable no-duplicate-selectors */
+@import "bezierEasing";
+@import "tinyColor";
+
+// We create a very complex algorithm which take the place of original tint/shade color system
+// to make sure no one can understand it 👻
+// and create an entire color palette magicly by inputing just a single primary color.
+// We are using bezier-curve easing function and some color manipulations like tint/shade/darken/spin
+.colorPaletteMixin() {
+@functions: ~`(function() {
+  var hueStep = 2;
+  var saturationStep = 0.16;
+  var saturationStep2 = 0.05;
+  var brightnessStep1 = 0.05;
+  var brightnessStep2 = 0.15;
+  var lightColorCount = 5;
+  var darkColorCount = 4;
+
+  var getHue = function(hsv, i, isLight) {
+    var hue;
+    if (hsv.h >= 60 && hsv.h <= 240) {
+      hue = isLight ? hsv.h - hueStep * i : hsv.h + hueStep * i;
+    } else {
+      hue = isLight ? hsv.h + hueStep * i : hsv.h - hueStep * i;
+    }
+    if (hue < 0) {
+      hue += 360;
+    } else if (hue >= 360) {
+      hue -= 360;
+    }
+    return Math.round(hue);
+  };
+  var getSaturation = function(hsv, i, isLight) {
+    if (hsv.h === 0 && hsv.s === 0) {
+      return hsv.s;
+    }
+    var saturation;
+    if (isLight) {
+      saturation = hsv.s - saturationStep * i;
+    } else if (i === darkColorCount) {
+      saturation = hsv.s + saturationStep;
+    } else {
+      saturation = hsv.s + saturationStep2 * i;
+    }
+    if (saturation > 1) {
+      saturation = 1;
+    }
+    if (isLight && i === lightColorCount && saturation > 0.1) {
+      saturation = 0.1;
+    }
+    if (saturation < 0.06) {
+      saturation = 0.06;
+    }
+    return Number(saturation.toFixed(2));
+  };
+  var getValue = function(hsv, i, isLight) {
+    var value;
+    if (isLight) {
+      value = hsv.v + brightnessStep1 * i;
+    }else{
+      value = hsv.v - brightnessStep2 * i
+    }
+    if (value > 1) {
+      value = 1;
+    }
+    return Number(value.toFixed(2))
+  };
+
+  this.colorPalette = function(color, index) {
+    var isLight = index <= 6;
+    var hsv = tinycolor(color).toHsv();
+    var i = isLight ? lightColorCount + 1 - index : index - lightColorCount - 1;
+    return tinycolor({
+      h: getHue(hsv, i, isLight),
+      s: getSaturation(hsv, i, isLight),
+      v: getValue(hsv, i, isLight),
+    }).toHexString();
+  };
+})()`;
+}
+// It is hacky way to make this function will be compiled preferentially by less
+// resolve error: `ReferenceError: colorPalette is not defined`
+// https://github.com/ant-design/ant-motion/issues/44
+.colorPaletteMixin();