ezr-antd 1.0.0

package/lib/input/style/otp.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (prefixCls: string, rootCls?: string) => readonly [(node: React.ReactElement) => React.ReactElement, string, string];
+export default _default;

package/lib/input/style/otp.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _internal = require("../../theme/internal");
+var _token = require("./token");
+// =============================== OTP ================================
+const genOTPStyle = token => {
+  const {
+    componentCls,
+    paddingXS
+  } = token;
+  return {
+    [componentCls]: {
+      display: 'inline-flex',
+      alignItems: 'center',
+      flexWrap: 'nowrap',
+      columnGap: paddingXS,
+      '&-rtl': {
+        direction: 'rtl'
+      },
+      [`${componentCls}-input`]: {
+        textAlign: 'center',
+        paddingInline: token.paddingXXS
+      },
+      // ================= Size =================
+      [`&${componentCls}-sm ${componentCls}-input`]: {
+        paddingInline: token.calc(token.paddingXXS).div(2).equal()
+      },
+      [`&${componentCls}-lg ${componentCls}-input`]: {
+        paddingInline: token.paddingXS
+      }
+    }
+  };
+};
+// ============================== Export ==============================
+var _default = exports.default = (0, _internal.genStyleHooks)(['Input', 'OTP'], token => {
+  const inputToken = (0, _internal.mergeToken)(token, (0, _token.initInputToken)(token));
+  return [genOTPStyle(inputToken)];
+}, _token.initComponentToken);

package/lib/input/style/token.d.ts

@@ -0,0 +1,97 @@
+import type { AliasToken, FullToken } from '../../theme/internal';
+export interface SharedComponentToken {
+    /**
+     * @desc 输入框横向内边距
+     * @descEN Horizontal padding of input
+     */
+    paddingInline: number;
+    /**
+     * @desc 小号输入框横向内边距
+     * @descEN Horizontal padding of small input
+     */
+    paddingInlineSM: number;
+    /**
+     * @desc 大号输入框横向内边距
+     * @descEN Horizontal padding of large input
+     */
+    paddingInlineLG: number;
+    /**
+     * @desc 输入框纵向内边距
+     * @descEN Vertical padding of input
+     */
+    paddingBlock: number;
+    /**
+     * @desc 小号输入框纵向内边距
+     * @descEN Vertical padding of small input
+     */
+    paddingBlockSM: number;
+    /**
+     * @desc 大号输入框纵向内边距
+     * @descEN Vertical padding of large input
+     */
+    paddingBlockLG: number;
+    /**
+     * @desc 前/后置标签背景色
+     * @descEN Background color of addon
+     */
+    addonBg: string;
+    /**
+     * @desc 悬浮态边框色
+     * @descEN Hover border color
+     */
+    hoverBorderColor: string;
+    /**
+     * @desc 激活态边框色
+     * @descEN Active border color
+     */
+    activeBorderColor: string;
+    /**
+     * @desc 激活态阴影
+     * @descEN Box-shadow when active
+     */
+    activeShadow: string;
+    /**
+     * @desc 错误状态时激活态阴影
+     * @descEN Box-shadow when active in error status
+     */
+    errorActiveShadow: string;
+    /**
+     * @desc 警告状态时激活态阴影
+     * @descEN Box-shadow when active in warning status
+     */
+    warningActiveShadow: string;
+    /**
+     * @desc 输入框hover状态时背景颜色
+     * @descEN Background color when the input box hovers
+     */
+    hoverBg: string;
+    /**
+     * @desc 输入框激活状态时背景颜色
+     * @descEN Background color when the input box is activated
+     */
+    activeBg: string;
+    /**
+     * @desc 字体大小
+     * @descEN Font size
+     */
+    inputFontSize: number;
+    /**
+     * @desc 大号字体大小
+     * @descEN Font size of large
+     */
+    inputFontSizeLG: number;
+    /**
+     * @desc 小号字体大小
+     * @descEN Font size of small
+     */
+    inputFontSizeSM: number;
+}
+export interface ComponentToken extends SharedComponentToken {
+}
+export interface SharedInputToken {
+    inputAffixPadding: number;
+}
+export interface InputToken extends FullToken<'Input'>, SharedInputToken {
+}
+export declare function initInputToken(token: AliasToken): SharedInputToken;
+export declare const initComponentToken: (token: AliasToken) => SharedComponentToken;

package/lib/input/style/token.js

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initComponentToken = void 0;
+exports.initInputToken = initInputToken;
+var _internal = require("../../theme/internal");
+function initInputToken(token) {
+  return (0, _internal.mergeToken)(token, {
+    inputAffixPadding: token.paddingXXS
+  });
+}
+const initComponentToken = token => {
+  const {
+    controlHeight,
+    fontSize,
+    lineHeight,
+    lineWidth,
+    controlHeightSM,
+    controlHeightLG,
+    fontSizeLG,
+    lineHeightLG,
+    paddingSM,
+    controlPaddingHorizontalSM,
+    controlPaddingHorizontal,
+    colorFillAlter,
+    colorPrimaryHover,
+    colorPrimary,
+    controlOutlineWidth,
+    controlOutline,
+    colorErrorOutline,
+    colorWarningOutline,
+    colorBgContainer
+  } = token;
+  return {
+    paddingBlock: Math.max(Math.round((controlHeight - fontSize * lineHeight) / 2 * 10) / 10 - lineWidth, 0),
+    paddingBlockSM: Math.max(Math.round((controlHeightSM - fontSize * lineHeight) / 2 * 10) / 10 - lineWidth, 0),
+    paddingBlockLG: Math.ceil((controlHeightLG - fontSizeLG * lineHeightLG) / 2 * 10) / 10 - lineWidth,
+    paddingInline: paddingSM - lineWidth,
+    paddingInlineSM: controlPaddingHorizontalSM - lineWidth,
+    paddingInlineLG: controlPaddingHorizontal - lineWidth,
+    addonBg: colorFillAlter,
+    activeBorderColor: colorPrimary,
+    hoverBorderColor: colorPrimaryHover,
+    activeShadow: `0 0 0 ${controlOutlineWidth}px ${controlOutline}`,
+    errorActiveShadow: `0 0 0 ${controlOutlineWidth}px ${colorErrorOutline}`,
+    warningActiveShadow: `0 0 0 ${controlOutlineWidth}px ${colorWarningOutline}`,
+    hoverBg: colorBgContainer,
+    activeBg: colorBgContainer,
+    inputFontSize: fontSize,
+    inputFontSizeLG: fontSizeLG,
+    inputFontSizeSM: fontSize
+  };
+};
+exports.initComponentToken = initComponentToken;

package/lib/input/style/variants.d.ts

@@ -0,0 +1,15 @@
+import type { CSSObject } from '@ant-design/cssinjs';
+import type { InputToken } from './token';
+export declare const genHoverStyle: (token: InputToken) => CSSObject;
+export declare const genDisabledStyle: (token: InputToken) => CSSObject;
+export declare const genBaseOutlinedStyle: (token: InputToken, options: {
+    borderColor: string;
+    hoverBorderColor: string;
+    activeBorderColor: string;
+    activeShadow: string;
+}) => CSSObject;
+export declare const genOutlinedStyle: (token: InputToken, extraStyles?: CSSObject) => CSSObject;
+export declare const genOutlinedGroupStyle: (token: InputToken) => CSSObject;
+export declare const genBorderlessStyle: (token: InputToken, extraStyles?: CSSObject) => CSSObject;
+export declare const genFilledStyle: (token: InputToken, extraStyles?: CSSObject) => CSSObject;
+export declare const genFilledGroupStyle: (token: InputToken) => CSSObject;

package/lib/input/style/variants.js

@@ -0,0 +1,253 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.genOutlinedStyle = exports.genOutlinedGroupStyle = exports.genHoverStyle = exports.genFilledStyle = exports.genFilledGroupStyle = exports.genDisabledStyle = exports.genBorderlessStyle = exports.genBaseOutlinedStyle = void 0;
+var _cssinjs = require("@ant-design/cssinjs");
+var _internal = require("../../theme/internal");
+const genHoverStyle = token => ({
+  borderColor: token.hoverBorderColor,
+  backgroundColor: token.hoverBg
+});
+exports.genHoverStyle = genHoverStyle;
+const genDisabledStyle = token => ({
+  color: token.colorTextDisabled,
+  backgroundColor: token.colorBgContainerDisabled,
+  borderColor: token.colorBorder,
+  boxShadow: 'none',
+  cursor: 'not-allowed',
+  opacity: 1,
+  'input[disabled], textarea[disabled]': {
+    cursor: 'not-allowed'
+  },
+  '&:hover:not([disabled])': Object.assign({}, genHoverStyle((0, _internal.mergeToken)(token, {
+    hoverBorderColor: token.colorBorder,
+    hoverBg: token.colorBgContainerDisabled
+  })))
+});
+/* ============== Outlined ============== */
+exports.genDisabledStyle = genDisabledStyle;
+const genBaseOutlinedStyle = (token, options) => ({
+  background: token.colorBgContainer,
+  borderWidth: token.lineWidth,
+  borderStyle: token.lineType,
+  borderColor: options.borderColor,
+  '&:hover': {
+    borderColor: options.hoverBorderColor,
+    backgroundColor: token.hoverBg
+  },
+  '&:focus, &:focus-within': {
+    borderColor: options.activeBorderColor,
+    boxShadow: options.activeShadow,
+    outline: 0,
+    backgroundColor: token.activeBg
+  }
+});
+exports.genBaseOutlinedStyle = genBaseOutlinedStyle;
+const genOutlinedStatusStyle = (token, options) => ({
+  [`&${token.componentCls}-status-${options.status}:not(${token.componentCls}-disabled)`]: Object.assign(Object.assign({}, genBaseOutlinedStyle(token, options)), {
+    [`${token.componentCls}-prefix, ${token.componentCls}-suffix`]: {
+      color: options.affixColor
+    }
+  }),
+  [`&${token.componentCls}-status-${options.status}${token.componentCls}-disabled`]: {
+    borderColor: options.borderColor
+  }
+});
+const genOutlinedStyle = (token, extraStyles) => ({
+  '&-outlined': Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, genBaseOutlinedStyle(token, {
+    borderColor: token.colorBorder,
+    hoverBorderColor: token.hoverBorderColor,
+    activeBorderColor: token.activeBorderColor,
+    activeShadow: token.activeShadow
+  })), {
+    [`&${token.componentCls}-disabled, &[disabled]`]: Object.assign({}, genDisabledStyle(token))
+  }), genOutlinedStatusStyle(token, {
+    status: 'error',
+    borderColor: token.colorError,
+    hoverBorderColor: token.colorErrorBorderHover,
+    activeBorderColor: token.colorError,
+    activeShadow: token.errorActiveShadow,
+    affixColor: token.colorError
+  })), genOutlinedStatusStyle(token, {
+    status: 'warning',
+    borderColor: token.colorWarning,
+    hoverBorderColor: token.colorWarningBorderHover,
+    activeBorderColor: token.colorWarning,
+    activeShadow: token.warningActiveShadow,
+    affixColor: token.colorWarning
+  })), extraStyles)
+});
+exports.genOutlinedStyle = genOutlinedStyle;
+const genOutlinedGroupStatusStyle = (token, options) => ({
+  [`&${token.componentCls}-group-wrapper-status-${options.status}`]: {
+    [`${token.componentCls}-group-addon`]: {
+      borderColor: options.addonBorderColor,
+      color: options.addonColor
+    }
+  }
+});
+const genOutlinedGroupStyle = token => ({
+  '&-outlined': Object.assign(Object.assign(Object.assign({
+    [`${token.componentCls}-group`]: {
+      '&-addon': {
+        background: token.addonBg,
+        border: `${(0, _cssinjs.unit)(token.lineWidth)} ${token.lineType} ${token.colorBorder}`
+      },
+      '&-addon:first-child': {
+        borderInlineEnd: 0
+      },
+      '&-addon:last-child': {
+        borderInlineStart: 0
+      }
+    }
+  }, genOutlinedGroupStatusStyle(token, {
+    status: 'error',
+    addonBorderColor: token.colorError,
+    addonColor: token.colorErrorText
+  })), genOutlinedGroupStatusStyle(token, {
+    status: 'warning',
+    addonBorderColor: token.colorWarning,
+    addonColor: token.colorWarningText
+  })), {
+    [`&${token.componentCls}-group-wrapper-disabled`]: {
+      [`${token.componentCls}-group-addon`]: Object.assign({}, genDisabledStyle(token))
+    }
+  })
+});
+/* ============ Borderless ============ */
+exports.genOutlinedGroupStyle = genOutlinedGroupStyle;
+const genBorderlessStyle = (token, extraStyles) => {
+  const {
+    componentCls
+  } = token;
+  return {
+    '&-borderless': Object.assign({
+      background: 'transparent',
+      border: 'none',
+      '&:focus, &:focus-within': {
+        outline: 'none'
+      },
+      // >>>>> Disabled
+      [`&${componentCls}-disabled, &[disabled]`]: {
+        color: token.colorTextDisabled,
+        cursor: 'not-allowed'
+      },
+      // >>>>> Status
+      [`&${componentCls}-status-error`]: {
+        '&, & input, & textarea': {
+          color: token.colorError
+        }
+      },
+      [`&${componentCls}-status-warning`]: {
+        '&, & input, & textarea': {
+          color: token.colorWarning
+        }
+      }
+    }, extraStyles)
+  };
+};
+/* ============== Filled ============== */
+exports.genBorderlessStyle = genBorderlessStyle;
+const genBaseFilledStyle = (token, options) => ({
+  background: options.bg,
+  borderWidth: token.lineWidth,
+  borderStyle: token.lineType,
+  borderColor: 'transparent',
+  'input&, & input, textarea&, & textarea': {
+    color: options === null || options === void 0 ? void 0 : options.inputColor
+  },
+  '&:hover': {
+    background: options.hoverBg
+  },
+  '&:focus, &:focus-within': {
+    outline: 0,
+    borderColor: options.activeBorderColor,
+    backgroundColor: token.activeBg
+  }
+});
+const genFilledStatusStyle = (token, options) => ({
+  [`&${token.componentCls}-status-${options.status}:not(${token.componentCls}-disabled)`]: Object.assign(Object.assign({}, genBaseFilledStyle(token, options)), {
+    [`${token.componentCls}-prefix, ${token.componentCls}-suffix`]: {
+      color: options.affixColor
+    }
+  })
+});
+const genFilledStyle = (token, extraStyles) => ({
+  '&-filled': Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, genBaseFilledStyle(token, {
+    bg: token.colorFillTertiary,
+    hoverBg: token.colorFillSecondary,
+    activeBorderColor: token.activeBorderColor
+  })), {
+    [`&${token.componentCls}-disabled, &[disabled]`]: Object.assign({}, genDisabledStyle(token))
+  }), genFilledStatusStyle(token, {
+    status: 'error',
+    bg: token.colorErrorBg,
+    hoverBg: token.colorErrorBgHover,
+    activeBorderColor: token.colorError,
+    inputColor: token.colorErrorText,
+    affixColor: token.colorError
+  })), genFilledStatusStyle(token, {
+    status: 'warning',
+    bg: token.colorWarningBg,
+    hoverBg: token.colorWarningBgHover,
+    activeBorderColor: token.colorWarning,
+    inputColor: token.colorWarningText,
+    affixColor: token.colorWarning
+  })), extraStyles)
+});
+exports.genFilledStyle = genFilledStyle;
+const genFilledGroupStatusStyle = (token, options) => ({
+  [`&${token.componentCls}-group-wrapper-status-${options.status}`]: {
+    [`${token.componentCls}-group-addon`]: {
+      background: options.addonBg,
+      color: options.addonColor
+    }
+  }
+});
+const genFilledGroupStyle = token => ({
+  '&-filled': Object.assign(Object.assign(Object.assign({
+    [`${token.componentCls}-group`]: {
+      '&-addon': {
+        background: token.colorFillTertiary
+      },
+      [`${token.componentCls}-filled:not(:focus):not(:focus-within)`]: {
+        '&:not(:first-child)': {
+          borderInlineStart: `${(0, _cssinjs.unit)(token.lineWidth)} ${token.lineType} ${token.colorSplit}`
+        },
+        '&:not(:last-child)': {
+          borderInlineEnd: `${(0, _cssinjs.unit)(token.lineWidth)} ${token.lineType} ${token.colorSplit}`
+        }
+      }
+    }
+  }, genFilledGroupStatusStyle(token, {
+    status: 'error',
+    addonBg: token.colorErrorBg,
+    addonColor: token.colorErrorText
+  })), genFilledGroupStatusStyle(token, {
+    status: 'warning',
+    addonBg: token.colorWarningBg,
+    addonColor: token.colorWarningText
+  })), {
+    [`&${token.componentCls}-group-wrapper-disabled`]: {
+      [`${token.componentCls}-group`]: {
+        '&-addon': {
+          background: token.colorFillTertiary,
+          color: token.colorTextDisabled
+        },
+        '&-addon:first-child': {
+          borderInlineStart: `${(0, _cssinjs.unit)(token.lineWidth)} ${token.lineType} ${token.colorBorder}`,
+          borderTop: `${(0, _cssinjs.unit)(token.lineWidth)} ${token.lineType} ${token.colorBorder}`,
+          borderBottom: `${(0, _cssinjs.unit)(token.lineWidth)} ${token.lineType} ${token.colorBorder}`
+        },
+        '&-addon:last-child': {
+          borderInlineEnd: `${(0, _cssinjs.unit)(token.lineWidth)} ${token.lineType} ${token.colorBorder}`,
+          borderTop: `${(0, _cssinjs.unit)(token.lineWidth)} ${token.lineType} ${token.colorBorder}`,
+          borderBottom: `${(0, _cssinjs.unit)(token.lineWidth)} ${token.lineType} ${token.colorBorder}`
+        }
+      }
+    }
+  })
+});
+exports.genFilledGroupStyle = genFilledGroupStyle;

package/lib/input/utils.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from 'react';
+import type { InputProps } from './Input';
+export declare function hasPrefixSuffix(props: {
+    prefix?: ReactNode;
+    suffix?: ReactNode;
+    allowClear?: InputProps['allowClear'];
+    showCount?: InputProps['showCount'];
+}): boolean;

package/lib/input/utils.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hasPrefixSuffix = hasPrefixSuffix;
+function hasPrefixSuffix(props) {
+  return !!(props.prefix || props.suffix || props.allowClear || props.showCount);
+}

package/lib/input-number/index.d.ts

@@ -0,0 +1,34 @@
+import * as React from 'react';
+import type { InputNumberProps as RcInputNumberProps, ValueType } from 'rc-input-number';
+import type { InputStatus } from '../_util/statusUtils';
+import type { Variant } from '../config-provider';
+import type { SizeType } from '../config-provider/SizeContext';
+export interface InputNumberProps<T extends ValueType = ValueType> extends Omit<RcInputNumberProps<T>, 'prefix' | 'size' | 'controls'> {
+    prefixCls?: string;
+    rootClassName?: string;
+    addonBefore?: React.ReactNode;
+    addonAfter?: React.ReactNode;
+    prefix?: React.ReactNode;
+    suffix?: React.ReactNode;
+    size?: SizeType;
+    disabled?: boolean;
+    /** @deprecated Use `variant` instead. */
+    bordered?: boolean;
+    status?: InputStatus;
+    controls?: boolean | {
+        upIcon?: React.ReactNode;
+        downIcon?: React.ReactNode;
+    };
+    /**
+     * @since 5.13.0
+     * @default "outlined"
+     */
+    variant?: Variant;
+}
+declare const TypedInputNumber: (<T extends ValueType = ValueType>(props: React.PropsWithChildren<InputNumberProps<T>> & React.RefAttributes<HTMLInputElement>) => React.ReactElement) & {
+    displayName?: string;
+    _InternalPanelDoNotUseOrYouWillBeFired: typeof PureInputNumber;
+};
+/** @private Internal Component. Do not use in your production. */
+declare const PureInputNumber: React.FC<InputNumberProps>;
+export default TypedInputNumber;