ezr-antd 1.0.0

package/es/_util/placements.js

@@ -0,0 +1,178 @@
+import { getArrowOffsetToken } from '../style/placementArrow';
+export function getOverflowOptions(placement, arrowOffset, arrowWidth, autoAdjustOverflow) {
+  if (autoAdjustOverflow === false) {
+    return {
+      adjustX: false,
+      adjustY: false
+    };
+  }
+  const overflow = autoAdjustOverflow && typeof autoAdjustOverflow === 'object' ? autoAdjustOverflow : {};
+  const baseOverflow = {};
+  switch (placement) {
+    case 'top':
+    case 'bottom':
+      baseOverflow.shiftX = arrowOffset.arrowOffsetHorizontal * 2 + arrowWidth;
+      baseOverflow.shiftY = true;
+      baseOverflow.adjustY = true;
+      break;
+    case 'left':
+    case 'right':
+      baseOverflow.shiftY = arrowOffset.arrowOffsetVertical * 2 + arrowWidth;
+      baseOverflow.shiftX = true;
+      baseOverflow.adjustX = true;
+      break;
+  }
+  const mergedOverflow = Object.assign(Object.assign({}, baseOverflow), overflow);
+  // Support auto shift
+  if (!mergedOverflow.shiftX) {
+    mergedOverflow.adjustX = true;
+  }
+  if (!mergedOverflow.shiftY) {
+    mergedOverflow.adjustY = true;
+  }
+  return mergedOverflow;
+}
+const PlacementAlignMap = {
+  left: {
+    points: ['cr', 'cl']
+  },
+  right: {
+    points: ['cl', 'cr']
+  },
+  top: {
+    points: ['bc', 'tc']
+  },
+  bottom: {
+    points: ['tc', 'bc']
+  },
+  topLeft: {
+    points: ['bl', 'tl']
+  },
+  leftTop: {
+    points: ['tr', 'tl']
+  },
+  topRight: {
+    points: ['br', 'tr']
+  },
+  rightTop: {
+    points: ['tl', 'tr']
+  },
+  bottomRight: {
+    points: ['tr', 'br']
+  },
+  rightBottom: {
+    points: ['bl', 'br']
+  },
+  bottomLeft: {
+    points: ['tl', 'bl']
+  },
+  leftBottom: {
+    points: ['br', 'bl']
+  }
+};
+const ArrowCenterPlacementAlignMap = {
+  topLeft: {
+    points: ['bl', 'tc']
+  },
+  leftTop: {
+    points: ['tr', 'cl']
+  },
+  topRight: {
+    points: ['br', 'tc']
+  },
+  rightTop: {
+    points: ['tl', 'cr']
+  },
+  bottomRight: {
+    points: ['tr', 'bc']
+  },
+  rightBottom: {
+    points: ['bl', 'cr']
+  },
+  bottomLeft: {
+    points: ['tl', 'bc']
+  },
+  leftBottom: {
+    points: ['br', 'cl']
+  }
+};
+const DisableAutoArrowList = new Set(['topLeft', 'topRight', 'bottomLeft', 'bottomRight', 'leftTop', 'leftBottom', 'rightTop', 'rightBottom']);
+export default function getPlacements(config) {
+  const {
+    arrowWidth,
+    autoAdjustOverflow,
+    arrowPointAtCenter,
+    offset,
+    borderRadius,
+    visibleFirst
+  } = config;
+  const halfArrowWidth = arrowWidth / 2;
+  const placementMap = {};
+  Object.keys(PlacementAlignMap).forEach(key => {
+    const template = arrowPointAtCenter && ArrowCenterPlacementAlignMap[key] || PlacementAlignMap[key];
+    const placementInfo = Object.assign(Object.assign({}, template), {
+      offset: [0, 0],
+      dynamicInset: true
+    });
+    placementMap[key] = placementInfo;
+    // Disable autoArrow since design is fixed position
+    if (DisableAutoArrowList.has(key)) {
+      placementInfo.autoArrow = false;
+    }
+    // Static offset
+    switch (key) {
+      case 'top':
+      case 'topLeft':
+      case 'topRight':
+        placementInfo.offset[1] = -halfArrowWidth - offset;
+        break;
+      case 'bottom':
+      case 'bottomLeft':
+      case 'bottomRight':
+        placementInfo.offset[1] = halfArrowWidth + offset;
+        break;
+      case 'left':
+      case 'leftTop':
+      case 'leftBottom':
+        placementInfo.offset[0] = -halfArrowWidth - offset;
+        break;
+      case 'right':
+      case 'rightTop':
+      case 'rightBottom':
+        placementInfo.offset[0] = halfArrowWidth + offset;
+        break;
+    }
+    // Dynamic offset
+    const arrowOffset = getArrowOffsetToken({
+      contentRadius: borderRadius,
+      limitVerticalRadius: true
+    });
+    if (arrowPointAtCenter) {
+      switch (key) {
+        case 'topLeft':
+        case 'bottomLeft':
+          placementInfo.offset[0] = -arrowOffset.arrowOffsetHorizontal - halfArrowWidth;
+          break;
+        case 'topRight':
+        case 'bottomRight':
+          placementInfo.offset[0] = arrowOffset.arrowOffsetHorizontal + halfArrowWidth;
+          break;
+        case 'leftTop':
+        case 'rightTop':
+          placementInfo.offset[1] = -arrowOffset.arrowOffsetHorizontal * 2 + halfArrowWidth;
+          break;
+        case 'leftBottom':
+        case 'rightBottom':
+          placementInfo.offset[1] = arrowOffset.arrowOffsetHorizontal * 2 - halfArrowWidth;
+          break;
+      }
+    }
+    // Overflow
+    placementInfo.overflow = getOverflowOptions(key, arrowOffset, arrowWidth, autoAdjustOverflow);
+    // VisibleFirst
+    if (visibleFirst) {
+      placementInfo.htmlRegion = 'visibleFirst';
+    }
+  });
+  return placementMap;
+}

package/es/_util/reactNode.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { AnyObject } from './type';
+export declare function isFragment(child: any): boolean;
+type RenderProps = AnyObject | ((originProps: AnyObject) => AnyObject | undefined);
+export declare const replaceElement: <P>(element: React.ReactNode, replacement: React.ReactNode, props?: RenderProps) => React.ReactNode;
+export declare function cloneElement<P>(element: React.ReactNode, props?: RenderProps): React.ReactElement;
+export {};

package/es/_util/reactNode.js

@@ -0,0 +1,13 @@
+import React from 'react';
+export function isFragment(child) {
+  return child && /*#__PURE__*/React.isValidElement(child) && child.type === React.Fragment;
+}
+export const replaceElement = (element, replacement, props) => {
+  if (! /*#__PURE__*/React.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/es/_util/responsiveObserver.d.ts

@@ -0,0 +1,22 @@
+export type Breakpoint = 'xxl' | 'xl' | 'lg' | 'md' | 'sm' | 'xs';
+export type BreakpointMap = Record<Breakpoint, string>;
+export type ScreenMap = Partial<Record<Breakpoint, boolean>>;
+export type ScreenSizeMap = Partial<Record<Breakpoint, number>>;
+export declare const responsiveArray: Breakpoint[];
+type SubscribeFunc = (screens: ScreenMap) => void;
+export default function useResponsiveObserver(): {
+    matchHandlers: {
+        [prop: string]: {
+            mql: MediaQueryList;
+            listener: ((this: MediaQueryList, ev: MediaQueryListEvent) => any) | null;
+        };
+    };
+    dispatch(pointMap: ScreenMap): boolean;
+    subscribe(func: SubscribeFunc): number;
+    unsubscribe(paramToken: number): void;
+    unregister(): void;
+    register(): void;
+    responsiveMap: BreakpointMap;
+};
+export declare const matchScreen: (screens: ScreenMap, screenSizes?: ScreenSizeMap) => number | undefined;
+export {};

package/es/_util/responsiveObserver.js

@@ -0,0 +1,106 @@
+import React from 'react';
+import { useToken } from '../theme/internal';
+export const responsiveArray = ['xxl', 'xl', 'lg', 'md', 'sm', 'xs'];
+const getResponsiveMap = token => ({
+  xs: `(max-width: ${token.screenXSMax}px)`,
+  sm: `(min-width: ${token.screenSM}px)`,
+  md: `(min-width: ${token.screenMD}px)`,
+  lg: `(min-width: ${token.screenLG}px)`,
+  xl: `(min-width: ${token.screenXL}px)`,
+  xxl: `(min-width: ${token.screenXXL}px)`
+});
+/**
+ * Ensures that the breakpoints token are valid, in good order
+ * For each breakpoint : screenMin <= screen <= screenMax and screenMax <= nextScreenMin
+ */
+const validateBreakpoints = token => {
+  const indexableToken = token;
+  const revBreakpoints = [].concat(responsiveArray).reverse();
+  revBreakpoints.forEach((breakpoint, i) => {
+    const breakpointUpper = breakpoint.toUpperCase();
+    const screenMin = `screen${breakpointUpper}Min`;
+    const screen = `screen${breakpointUpper}`;
+    if (!(indexableToken[screenMin] <= indexableToken[screen])) {
+      throw new Error(`${screenMin}<=${screen} fails : !(${indexableToken[screenMin]}<=${indexableToken[screen]})`);
+    }
+    if (i < revBreakpoints.length - 1) {
+      const screenMax = `screen${breakpointUpper}Max`;
+      if (!(indexableToken[screen] <= indexableToken[screenMax])) {
+        throw new Error(`${screen}<=${screenMax} fails : !(${indexableToken[screen]}<=${indexableToken[screenMax]})`);
+      }
+      const nextBreakpointUpperMin = revBreakpoints[i + 1].toUpperCase();
+      const nextScreenMin = `screen${nextBreakpointUpperMin}Min`;
+      if (!(indexableToken[screenMax] <= indexableToken[nextScreenMin])) {
+        throw new Error(`${screenMax}<=${nextScreenMin} fails : !(${indexableToken[screenMax]}<=${indexableToken[nextScreenMin]})`);
+      }
+    }
+  });
+  return token;
+};
+export default function useResponsiveObserver() {
+  const [, token] = useToken();
+  const responsiveMap = getResponsiveMap(validateBreakpoints(token));
+  // To avoid repeat create instance, we add `useMemo` here.
+  return React.useMemo(() => {
+    const subscribers = new Map();
+    let subUid = -1;
+    let screens = {};
+    return {
+      matchHandlers: {},
+      dispatch(pointMap) {
+        screens = pointMap;
+        subscribers.forEach(func => func(screens));
+        return subscribers.size >= 1;
+      },
+      subscribe(func) {
+        if (!subscribers.size) this.register();
+        subUid += 1;
+        subscribers.set(subUid, func);
+        func(screens);
+        return subUid;
+      },
+      unsubscribe(paramToken) {
+        subscribers.delete(paramToken);
+        if (!subscribers.size) this.unregister();
+      },
+      unregister() {
+        Object.keys(responsiveMap).forEach(screen => {
+          const matchMediaQuery = responsiveMap[screen];
+          const handler = this.matchHandlers[matchMediaQuery];
+          handler === null || handler === void 0 ? void 0 : handler.mql.removeListener(handler === null || handler === void 0 ? void 0 : handler.listener);
+        });
+        subscribers.clear();
+      },
+      register() {
+        Object.keys(responsiveMap).forEach(screen => {
+          const matchMediaQuery = responsiveMap[screen];
+          const listener = ({
+            matches
+          }) => {
+            this.dispatch(Object.assign(Object.assign({}, screens), {
+              [screen]: matches
+            }));
+          };
+          const mql = window.matchMedia(matchMediaQuery);
+          mql.addListener(listener);
+          this.matchHandlers[matchMediaQuery] = {
+            mql,
+            listener
+          };
+          listener(mql);
+        });
+      },
+      responsiveMap
+    };
+  }, [token]);
+}
+export const matchScreen = (screens, screenSizes) => {
+  if (screenSizes && typeof screenSizes === 'object') {
+    for (let i = 0; i < responsiveArray.length; i++) {
+      const breakpoint = responsiveArray[i];
+      if (screens[breakpoint] && screenSizes[breakpoint] !== undefined) {
+        return screenSizes[breakpoint];
+      }
+    }
+  }
+};

package/es/_util/scrollTo.d.ts

@@ -0,0 +1,10 @@
+interface ScrollToOptions {
+    /** Scroll container, default as window */
+    getContainer?: () => HTMLElement | Window | Document;
+    /** Scroll end callback */
+    callback?: () => void;
+    /** Animation duration, default as 450 */
+    duration?: number;
+}
+export default function scrollTo(y: number, options?: ScrollToOptions): void;
+export {};

package/es/_util/scrollTo.js

@@ -0,0 +1,31 @@
+import raf from "rc-util/es/raf";
+import { easeInOutCubic } from './easings';
+import getScroll, { isWindow } from './getScroll';
+export default function scrollTo(y, options = {}) {
+  const {
+    getContainer = () => window,
+    callback,
+    duration = 450
+  } = options;
+  const container = getContainer();
+  const scrollTop = getScroll(container);
+  const startTime = Date.now();
+  const frameFunc = () => {
+    const timestamp = Date.now();
+    const time = timestamp - startTime;
+    const nextScrollTop = easeInOutCubic(time > duration ? duration : time, scrollTop, y, duration);
+    if (isWindow(container)) {
+      container.scrollTo(window.pageXOffset, nextScrollTop);
+    } else if (container instanceof Document || container.constructor.name === 'HTMLDocument') {
+      container.documentElement.scrollTop = nextScrollTop;
+    } else {
+      container.scrollTop = nextScrollTop;
+    }
+    if (time < duration) {
+      raf(frameFunc);
+    } else if (typeof callback === 'function') {
+      callback();
+    }
+  };
+  raf(frameFunc);
+}

package/es/_util/statusUtils.d.ts

@@ -0,0 +1,6 @@
+import type { ValidateStatus } from '../form/FormItem';
+declare const _InputStatuses: readonly ["warning", "error", ""];
+export type InputStatus = (typeof _InputStatuses)[number];
+export declare function getStatusClassNames(prefixCls: string, status?: ValidateStatus, hasFeedback?: boolean): string;
+export declare const getMergedStatus: (contextStatus?: ValidateStatus, customStatus?: InputStatus) => "" | "error" | "success" | "warning" | "validating" | undefined;
+export {};

package/es/_util/statusUtils.js

@@ -0,0 +1,12 @@
+import classNames from 'classnames';
+const _InputStatuses = ['warning', 'error', ''];
+export function getStatusClassNames(prefixCls, status, hasFeedback) {
+  return classNames({
+    [`${prefixCls}-status-success`]: status === 'success',
+    [`${prefixCls}-status-warning`]: status === 'warning',
+    [`${prefixCls}-status-error`]: status === 'error',
+    [`${prefixCls}-status-validating`]: status === 'validating',
+    [`${prefixCls}-has-feedback`]: hasFeedback
+  });
+}
+export const getMergedStatus = (contextStatus, customStatus) => customStatus || contextStatus;

package/es/_util/styleChecker.d.ts

@@ -0,0 +1,3 @@
+import { isStyleSupport } from 'rc-util/lib/Dom/styleChecker';
+export declare const canUseDocElement: () => false | HTMLElement;
+export { isStyleSupport };

package/es/_util/styleChecker.js

@@ -0,0 +1,4 @@
+import canUseDom from "rc-util/es/Dom/canUseDom";
+import { isStyleSupport } from "rc-util/es/Dom/styleChecker";
+export const canUseDocElement = () => canUseDom() && window.document.documentElement;
+export { isStyleSupport };

package/es/_util/throttleByAnimationFrame.d.ts

@@ -0,0 +1,5 @@
+declare function throttleByAnimationFrame<T extends any[]>(fn: (...args: T) => void): {
+    (...args: T): void;
+    cancel(): void;
+};
+export default throttleByAnimationFrame;

package/es/_util/throttleByAnimationFrame.js

@@ -0,0 +1,20 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import raf from "rc-util/es/raf";
+function throttleByAnimationFrame(fn) {
+  let requestId;
+  const later = args => () => {
+    requestId = null;
+    fn.apply(void 0, _toConsumableArray(args));
+  };
+  const throttled = (...args) => {
+    if (requestId == null) {
+      requestId = raf(later(args));
+    }
+  };
+  throttled.cancel = () => {
+    raf.cancel(requestId);
+    requestId = null;
+  };
+  return throttled;
+}
+export default throttleByAnimationFrame;

package/es/_util/toList.d.ts

@@ -0,0 +1 @@
+export default function toList<T>(candidate: T | T[], skipEmpty?: boolean): T[];

package/es/_util/toList.js

@@ -0,0 +1,4 @@
+export default function toList(candidate, skipEmpty = false) {
+  if (skipEmpty && (candidate === undefined || candidate === null)) return [];
+  return Array.isArray(candidate) ? candidate : [candidate];
+}

package/es/_util/transKeys.d.ts

@@ -0,0 +1,3 @@
+import type { TransferKey } from '../transfer/interface';
+export declare const groupKeysMap: (keys: TransferKey[]) => Map<import("react").Key, number>;
+export declare const groupDisabledKeysMap: <RecordType extends any[]>(dataSource: RecordType) => Map<import("react").Key, number>;

package/es/_util/transKeys.js

@@ -0,0 +1,19 @@
+export const groupKeysMap = keys => {
+  const map = new Map();
+  keys.forEach((key, index) => {
+    map.set(key, index);
+  });
+  return map;
+};
+export const groupDisabledKeysMap = dataSource => {
+  const map = new Map();
+  dataSource.forEach(({
+    disabled,
+    key
+  }, index) => {
+    if (disabled) {
+      map.set(key, index);
+    }
+  });
+  return map;
+};

package/es/_util/type.d.ts

@@ -0,0 +1,54 @@
+import type React from 'react';
+/** https://github.com/Microsoft/TypeScript/issues/29729 */
+export type LiteralUnion<T extends string> = T | (string & {});
+export type AnyObject = Record<PropertyKey, any>;
+export type CustomComponent<P = AnyObject> = React.ComponentType<P> | string;
+/**
+ * Get component props
+ * @example
+ * ```ts
+ * import { Checkbox } from 'antd'
+ * import type { GetProps } from 'antd';
+ *
+ * type CheckboxGroupProps = GetProps<typeof Checkbox.Group>
+ * ```
+ * @since 5.13.0
+ */
+export type GetProps<T extends React.ComponentType<any> | object> = T extends React.ComponentType<infer P> ? P : T extends object ? T : never;
+/**
+ * Get component props by component name
+ * @example
+ * ```ts
+ * import { Select } from 'antd';
+ * import type { GetProp, SelectProps } from 'antd';
+ *
+ * type SelectOption1 = GetProp<SelectProps, 'options'>[number];
+ * // or
+ * type SelectOption2 = GetProp<typeof Select, 'options'>[number];
+ *
+ * const onChange: GetProp<typeof Select, 'onChange'> = (value, option) => {
+ *  // Do something
+ * };
+ * ```
+ * @since 5.13.0
+ */
+export type GetProp<T extends React.ComponentType<any> | object, PropName extends keyof GetProps<T>> = NonNullable<GetProps<T>[PropName]>;
+type ReactRefComponent<Props extends {
+    ref?: React.Ref<any> | string;
+}> = (props: Props) => React.ReactNode;
+type ExtractRefAttributesRef<T> = T extends React.RefAttributes<infer P> ? P : never;
+/**
+ * Get component ref
+ * @example
+ * ```ts
+ * import { Input } from 'antd';
+ * import type { GetRef } from 'antd';
+ *
+ * type InputRef = GetRef<typeof Input>;
+ * ```
+ * @since 5.13.0
+ */
+export type GetRef<T extends ReactRefComponent<any> | React.Component<any>> = T extends React.Component<any> ? T : T extends React.ComponentType<infer P> ? ExtractRefAttributesRef<P> : never;
+export type GetContextProps<T> = T extends React.Context<infer P> ? P : never;
+export type GetContextProp<T extends React.Context<any>, PropName extends keyof GetContextProps<T>> = NonNullable<GetContextProps<T>[PropName]>;
+export {};

package/es/_util/type.js

@@ -0,0 +1 @@
+export {};

package/es/_util/warning.d.ts

@@ -0,0 +1,31 @@
+import * as React from 'react';
+export declare function noop(): void;
+export declare function resetWarned(): void;
+type Warning = (valid: boolean, component: string, message?: string) => void;
+declare let warning: Warning;
+type BaseTypeWarning = (valid: boolean, 
+/**
+ * - deprecated: Some API will be removed in future but still support now.
+ * - usage: Some API usage is not correct.
+ * - breaking: Breaking change like API is removed.
+ */
+type: 'deprecated' | 'usage' | 'breaking', message?: string) => void;
+type TypeWarning = BaseTypeWarning & {
+    deprecated: (valid: boolean, oldProp: string, newProp: string, message?: string) => void;
+};
+export interface WarningContextProps {
+    /**
+     * @descCN 设置警告等级，设置 `false` 时会将废弃相关信息聚合为单条信息。
+     * @descEN Set the warning level. When set to `false`, discard related information will be aggregated into a single message.
+     * @since 5.10.0
+     */
+    strict?: boolean;
+}
+export declare const WarningContext: React.Context<WarningContextProps>;
+/**
+ * This is a hook but we not named as `useWarning`
+ * since this is only used in development.
+ * We should always wrap this in `if (process.env.NODE_ENV !== 'production')` condition
+ */
+export declare const devUseWarning: (component: string) => TypeWarning;
+export default warning;

package/es/_util/warning.js

@@ -0,0 +1,59 @@
+import * as React from 'react';
+import rcWarning, { resetWarned as rcResetWarned } from "rc-util/es/warning";
+export function noop() {}
+let deprecatedWarnList = null;
+export function resetWarned() {
+  deprecatedWarnList = null;
+  rcResetWarned();
+}
+// eslint-disable-next-line import/no-mutable-exports
+let warning = noop;
+if (process.env.NODE_ENV !== 'production') {
+  warning = (valid, component, message) => {
+    rcWarning(valid, `[antd: ${component}] ${message}`);
+    // StrictMode will inject console which will not throw warning in React 17.
+    if (process.env.NODE_ENV === 'test') {
+      resetWarned();
+    }
+  };
+}
+export const WarningContext = /*#__PURE__*/React.createContext({});
+/**
+ * This is a hook but we not named as `useWarning`
+ * since this is only used in development.
+ * We should always wrap this in `if (process.env.NODE_ENV !== 'production')` condition
+ */
+export const devUseWarning = process.env.NODE_ENV !== 'production' ? component => {
+  const {
+    strict
+  } = React.useContext(WarningContext);
+  const typeWarning = (valid, type, message) => {
+    if (!valid) {
+      if (strict === false && type === 'deprecated') {
+        const existWarning = deprecatedWarnList;
+        if (!deprecatedWarnList) {
+          deprecatedWarnList = {};
+        }
+        deprecatedWarnList[component] = deprecatedWarnList[component] || [];
+        if (!deprecatedWarnList[component].includes(message || '')) {
+          deprecatedWarnList[component].push(message || '');
+        }
+        // Warning for the first time
+        if (!existWarning) {
+          console.warn('[antd] There exists deprecated usage in your code:', deprecatedWarnList);
+        }
+      } else {
+        process.env.NODE_ENV !== "production" ? warning(valid, component, message) : void 0;
+      }
+    }
+  };
+  typeWarning.deprecated = (valid, oldProp, newProp, message) => {
+    typeWarning(valid, 'deprecated', `\`${oldProp}\` is deprecated. Please use \`${newProp}\` instead.${message ? ` ${message}` : ''}`);
+  };
+  return typeWarning;
+} : () => {
+  const noopWarning = () => {};
+  noopWarning.deprecated = noop;
+  return noopWarning;
+};
+export default warning;

package/es/_util/wave/WaveEffect.d.ts

@@ -0,0 +1,8 @@
+import type { ShowWaveEffect } from './interface';
+export interface WaveEffectProps {
+    className: string;
+    target: HTMLElement;
+    component?: string;
+}
+declare const showWaveEffect: ShowWaveEffect;
+export default showWaveEffect;