@infomaximum/ui-kit 0.9.1

package/dist/components/InputNumber/utils/BigIntDecimal.js

@@ -0,0 +1,124 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { isEmpty, isE, num2str, validateNumber, trimNumber } from "./numberUtil.js";
+class BigIntDecimal {
+  constructor(value) {
+    __publicField(this, "origin", "");
+    __publicField(this, "negative");
+    __publicField(this, "integer");
+    __publicField(this, "decimal");
+    /** BigInt will convert `0009` to `9`. We need record the len of decimal */
+    __publicField(this, "decimalLen", 0);
+    __publicField(this, "empty");
+    __publicField(this, "nan");
+    if (isEmpty(value)) {
+      this.empty = true;
+      return;
+    }
+    this.origin = String(value);
+    if (value === "-" || Number.isNaN(value)) {
+      this.nan = true;
+      return;
+    }
+    let mergedValue = value;
+    if (isE(mergedValue)) {
+      mergedValue = Number(mergedValue);
+    }
+    mergedValue = typeof mergedValue === "string" ? mergedValue : num2str(mergedValue);
+    if (validateNumber(mergedValue)) {
+      const trimRet = trimNumber(mergedValue);
+      this.negative = trimRet.negative;
+      const numbers = trimRet.trimStr.split(".");
+      this.integer = BigInt(numbers[0]);
+      const decimalStr = numbers[1] || "0";
+      this.decimal = BigInt(decimalStr);
+      this.decimalLen = decimalStr.length;
+    } else {
+      this.nan = true;
+    }
+  }
+  getMark() {
+    return this.negative ? "-" : "";
+  }
+  getIntegerStr() {
+    var _a;
+    return ((_a = this.integer) == null ? void 0 : _a.toString()) || "";
+  }
+  getDecimalStr() {
+    var _a;
+    return (((_a = this.decimal) == null ? void 0 : _a.toString()) || "").padStart(this.decimalLen, "0");
+  }
+  alignDecimal(decimalLength) {
+    const str = `${this.getMark()}${this.getIntegerStr()}${this.getDecimalStr().padEnd(decimalLength, "0")}`;
+    return BigInt(str);
+  }
+  negate() {
+    const clone = new BigIntDecimal(this.toString());
+    clone.negative = !clone.negative;
+    return clone;
+  }
+  cal(offset, calculator, calDecimalLen) {
+    const maxDecimalLength = Math.max(this.getDecimalStr().length, offset.getDecimalStr().length);
+    const myAlignedDecimal = this.alignDecimal(maxDecimalLength);
+    const offsetAlignedDecimal = offset.alignDecimal(maxDecimalLength);
+    const valueStr = calculator(myAlignedDecimal, offsetAlignedDecimal).toString();
+    const nextDecimalLength = calDecimalLen(maxDecimalLength);
+    const {
+      negativeStr,
+      trimStr
+    } = trimNumber(valueStr);
+    const hydrateValueStr = `${negativeStr}${trimStr.padStart(nextDecimalLength + 1, "0")}`;
+    return new BigIntDecimal(`${hydrateValueStr.slice(0, -nextDecimalLength)}.${hydrateValueStr.slice(-nextDecimalLength)}`);
+  }
+  add(value) {
+    if (this.isInvalidate()) {
+      return new BigIntDecimal(value);
+    }
+    const offset = new BigIntDecimal(value);
+    if (offset.isInvalidate()) {
+      return this;
+    }
+    return this.cal(offset, (num1, num2) => num1 + num2, (len) => len);
+  }
+  multi(value) {
+    const target = new BigIntDecimal(value);
+    if (this.isInvalidate() || target.isInvalidate()) {
+      return new BigIntDecimal(NaN);
+    }
+    return this.cal(target, (num1, num2) => num1 * num2, (len) => len * 2);
+  }
+  isEmpty() {
+    return this.empty;
+  }
+  isNaN() {
+    return this.nan;
+  }
+  isInvalidate() {
+    return this.isEmpty() || this.isNaN();
+  }
+  equals(target) {
+    return this.toString() === (target == null ? void 0 : target.toString());
+  }
+  lessEquals(target) {
+    return this.add(target.negate().toString()).toNumber() <= 0;
+  }
+  toNumber() {
+    if (this.isNaN()) {
+      return NaN;
+    }
+    return Number(this.toString());
+  }
+  toString(safe = true) {
+    if (!safe) {
+      return this.origin;
+    }
+    if (this.isInvalidate()) {
+      return "";
+    }
+    return trimNumber(`${this.getMark()}${this.getIntegerStr()}.${this.getDecimalStr()}`).fullStr;
+  }
+}
+export {
+  BigIntDecimal
+};

package/dist/components/InputNumber/utils/MiniDecimal.d.ts

@@ -0,0 +1,3 @@
+import { DecimalClass, ValueType } from './interface';
+export declare function getMiniDecimal(value: ValueType | undefined | null): DecimalClass;
+export declare function toFixed(numStr: string, separatorStr: string, precision?: number, cutOnly?: boolean): string;

package/dist/components/InputNumber/utils/MiniDecimal.js

@@ -0,0 +1,42 @@
+import { isNumber } from "lodash-es";
+import { BigIntDecimal } from "./BigIntDecimal.js";
+import { NumberDecimal } from "./NumberDecimal.js";
+import { trimNumber } from "./numberUtil.js";
+import { supportBigInt } from "./supportUtil.js";
+function getMiniDecimal(value) {
+  if (supportBigInt()) {
+    return new BigIntDecimal(value);
+  }
+  return new NumberDecimal(value);
+}
+function toFixed(numStr, separatorStr, precision, cutOnly = false) {
+  if (numStr === "" || !isNumber(precision)) {
+    return "";
+  }
+  const {
+    negativeStr,
+    integerStr,
+    decimalStr
+  } = trimNumber(numStr);
+  const precisionDecimalStr = `${separatorStr}${decimalStr}`;
+  const numberWithoutDecimal = `${negativeStr}${integerStr}`;
+  if (precision >= 0) {
+    const advancedNum = Number(decimalStr[precision]);
+    if (advancedNum >= 5 && !cutOnly) {
+      const advancedDecimal = getMiniDecimal(numStr).add(`${negativeStr}0.${"0".repeat(precision)}${10 - advancedNum}`);
+      return toFixed(advancedDecimal.toString(), separatorStr, precision, cutOnly);
+    }
+    if (precision === 0) {
+      return numberWithoutDecimal;
+    }
+    return `${numberWithoutDecimal}${separatorStr}${decimalStr.padEnd(precision, "0").slice(0, precision)}`;
+  }
+  if (precisionDecimalStr === ".0") {
+    return numberWithoutDecimal;
+  }
+  return `${numberWithoutDecimal}${precisionDecimalStr}`;
+}
+export {
+  getMiniDecimal,
+  toFixed
+};

package/dist/components/InputNumber/utils/NumberDecimal.d.ts

@@ -0,0 +1,17 @@
+import { DecimalClass, ValueType } from './interface';
+export declare class NumberDecimal implements DecimalClass {
+    private origin;
+    private number;
+    private empty;
+    constructor(value: ValueType | undefined | null);
+    negate(): NumberDecimal;
+    add(value: ValueType): NumberDecimal;
+    multi(value: ValueType): NumberDecimal;
+    isEmpty(): boolean | undefined;
+    isNaN(): boolean;
+    isInvalidate(): boolean;
+    equals(target: DecimalClass): boolean;
+    lessEquals(target: DecimalClass): boolean;
+    toNumber(): number;
+    toString(safe?: boolean): string;
+}

package/dist/components/InputNumber/utils/NumberDecimal.js

@@ -0,0 +1,83 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { isEmpty, getNumberPrecision, num2str } from "./numberUtil.js";
+class NumberDecimal {
+  constructor(value) {
+    __publicField(this, "origin", "");
+    __publicField(this, "number", 0);
+    __publicField(this, "empty");
+    if (isEmpty(value)) {
+      this.empty = true;
+      return;
+    }
+    this.origin = String(value);
+    this.number = Number(value);
+  }
+  negate() {
+    return new NumberDecimal(-this.toNumber());
+  }
+  add(value) {
+    if (this.isInvalidate()) {
+      return new NumberDecimal(value);
+    }
+    const target = Number(value);
+    if (Number.isNaN(target)) {
+      return this;
+    }
+    const number = this.number + target;
+    if (number > Number.MAX_SAFE_INTEGER) {
+      return new NumberDecimal(Number.MAX_SAFE_INTEGER);
+    }
+    if (number < Number.MIN_SAFE_INTEGER) {
+      return new NumberDecimal(Number.MIN_SAFE_INTEGER);
+    }
+    const maxPrecision = Math.max(getNumberPrecision(this.number), getNumberPrecision(target));
+    return new NumberDecimal(number.toFixed(maxPrecision));
+  }
+  multi(value) {
+    const target = Number(value);
+    if (this.isInvalidate() || Number.isNaN(target)) {
+      return new NumberDecimal(NaN);
+    }
+    const number = this.number * target;
+    if (number > Number.MAX_SAFE_INTEGER) {
+      return new NumberDecimal(Number.MAX_SAFE_INTEGER);
+    }
+    if (number < Number.MIN_SAFE_INTEGER) {
+      return new NumberDecimal(Number.MIN_SAFE_INTEGER);
+    }
+    const maxPrecision = Math.max(getNumberPrecision(this.number), getNumberPrecision(target));
+    return new NumberDecimal(number.toFixed(maxPrecision));
+  }
+  isEmpty() {
+    return this.empty;
+  }
+  isNaN() {
+    return Number.isNaN(this.number);
+  }
+  isInvalidate() {
+    return this.isEmpty() || this.isNaN();
+  }
+  equals(target) {
+    return this.toNumber() === (target == null ? void 0 : target.toNumber());
+  }
+  lessEquals(target) {
+    return this.add(target.negate().toString()).toNumber() <= 0;
+  }
+  toNumber() {
+    return this.number;
+  }
+  toString(safe = true) {
+    if (!safe) {
+      return this.origin;
+    }
+    if (this.isInvalidate()) {
+      return "";
+    }
+    return num2str(this.number);
+  }
+}
+export {
+  NumberDecimal
+};

package/dist/components/InputNumber/utils/index.d.ts

@@ -0,0 +1,4 @@
+export type { DecimalClass, ValueType } from './interface';
+export { getMiniDecimal, toFixed } from './MiniDecimal';
+export { getNumberPrecision, num2str, trimNumber, validateNumber } from './numberUtil';
+export { getDecupleSteps } from './numberUtil';

package/dist/components/InputNumber/utils/interface.d.ts

@@ -0,0 +1,13 @@
+export type ValueType = string | number;
+export interface DecimalClass {
+    add: (value: ValueType) => DecimalClass;
+    multi: (value: ValueType) => DecimalClass;
+    isEmpty: () => boolean | undefined;
+    isNaN: () => boolean | undefined;
+    isInvalidate: () => boolean | undefined;
+    toNumber: () => number;
+    toString: (safe?: boolean) => string;
+    equals: (target: DecimalClass) => boolean;
+    lessEquals: (target: DecimalClass) => boolean;
+    negate: () => DecimalClass;
+}

package/dist/components/InputNumber/utils/numberUtil.d.ts

@@ -0,0 +1,15 @@
+import { ValueType } from './interface';
+export declare function isEmpty(value: ValueType | null | undefined): value is null | undefined;
+export declare function trimNumber(numStr: string): {
+    negative: boolean;
+    negativeStr: string;
+    trimStr: string;
+    integerStr: string;
+    decimalStr: string;
+    fullStr: string;
+};
+export declare function isE(number: string | number): boolean;
+export declare function getNumberPrecision(number: string | number): number;
+export declare function num2str(number: number): string;
+export declare function validateNumber(num: string | number): boolean;
+export declare function getDecupleSteps(step: string | number): string;

package/dist/components/InputNumber/utils/numberUtil.js

@@ -0,0 +1,91 @@
+import { supportBigInt } from "./supportUtil.js";
+function isEmpty(value) {
+  return !value && value !== 0 && !Number.isNaN(value) || !String(value).trim();
+}
+function trimNumber(numStr) {
+  let str = numStr.trim();
+  let negative = str.startsWith("-");
+  if (negative) {
+    str = str.slice(1);
+  }
+  str = str.replace(/(\.\d*[^0])0*$/, "$1").replace(/\.0*$/, "").replace(/^0+/, "");
+  if (str.startsWith(".")) {
+    str = `0${str}`;
+  }
+  const trimStr = str || "0";
+  const splitNumber = trimStr.split(".");
+  const integerStr = splitNumber[0] || "0";
+  const decimalStr = splitNumber[1] || "0";
+  if (integerStr === "0" && decimalStr === "0") {
+    negative = false;
+  }
+  const negativeStr = negative ? "-" : "";
+  return {
+    negative,
+    negativeStr,
+    trimStr,
+    integerStr,
+    decimalStr,
+    fullStr: `${negativeStr}${trimStr}`
+  };
+}
+function isE(number) {
+  const str = String(number);
+  return !Number.isNaN(Number(str)) && str.includes("e");
+}
+function getNumberPrecision(number) {
+  const numStr = String(number);
+  if (isE(number)) {
+    let precision = Number(numStr.slice(numStr.indexOf("e-") + 2));
+    const decimalMatch = numStr.match(/\.(\d+)/);
+    if (decimalMatch == null ? void 0 : decimalMatch[1]) {
+      precision += decimalMatch[1].length;
+    }
+    return precision;
+  }
+  return numStr.includes(".") && validateNumber(numStr) ? numStr.length - numStr.indexOf(".") - 1 : 0;
+}
+function num2str(number) {
+  let numStr = String(number);
+  if (isE(number)) {
+    if (number > Number.MAX_SAFE_INTEGER) {
+      return String(supportBigInt() ? BigInt(number).toString() : Number.MAX_SAFE_INTEGER);
+    }
+    if (number < Number.MIN_SAFE_INTEGER) {
+      return String(supportBigInt() ? BigInt(number).toString() : Number.MIN_SAFE_INTEGER);
+    }
+    numStr = number.toFixed(getNumberPrecision(numStr));
+  }
+  return trimNumber(numStr).fullStr;
+}
+function validateNumber(num) {
+  if (typeof num === "number") {
+    return !Number.isNaN(num);
+  }
+  if (!num) {
+    return false;
+  }
+  return (
+    // Normal type: 11.28
+    /^\s*-?\d+(\.\d+)?\s*$/.test(num) || // Pre-number: 1.
+    /^\s*-?\d+\.\s*$/.test(num) || // Post-number: .1
+    /^\s*-?\.\d+\s*$/.test(num)
+  );
+}
+function getDecupleSteps(step) {
+  const stepStr = typeof step === "number" ? num2str(step) : trimNumber(step).fullStr;
+  const hasPoint = stepStr.includes(".");
+  if (!hasPoint) {
+    return step + "0";
+  }
+  return trimNumber(stepStr.replace(/(\d)\.(\d)/g, "$1$2.")).fullStr;
+}
+export {
+  getDecupleSteps,
+  getNumberPrecision,
+  isE,
+  isEmpty,
+  num2str,
+  trimNumber,
+  validateNumber
+};

package/dist/components/InputNumber/utils/supportUtil.d.ts

@@ -0,0 +1 @@
+export declare function supportBigInt(): boolean;

package/dist/components/InputNumber/utils/supportUtil.js

@@ -0,0 +1,6 @@
+function supportBigInt() {
+  return typeof BigInt === "function";
+}
+export {
+  supportBigInt
+};

package/dist/components/InternalPicker/config/docsStoriesLocale.d.ts

@@ -0,0 +1,2 @@
+import { Locale } from '../../ConfigProvider';
+export declare const docsStoriesLocale: Locale;

package/dist/components/InternalPicker/config/index.d.ts

@@ -0,0 +1,2 @@
+export { docsStoriesLocale } from './docsStoriesLocale';
+export type { PickerLocale } from './types';

package/dist/components/InternalPicker/config/types.d.ts

@@ -0,0 +1,25 @@
+import { Locale } from 'rc-picker/es/interface';
+type SinglePlaceholder = string;
+type RangePlaceholder = [string, string];
+interface PlaceholderLocale {
+    datePlaceholder?: SinglePlaceholder;
+    timePlaceholder?: SinglePlaceholder;
+    yearPlaceholder?: SinglePlaceholder;
+    quarterPlaceholder?: SinglePlaceholder;
+    monthPlaceholder?: SinglePlaceholder;
+    weekPlaceholder?: SinglePlaceholder;
+    rangeDatePlaceholder?: RangePlaceholder;
+    rangeTimePlaceholder?: RangePlaceholder;
+    rangeYearPlaceholder?: RangePlaceholder;
+    rangeQuarterPlaceholder?: RangePlaceholder;
+    rangeMonthPlaceholder?: RangePlaceholder;
+    rangeWeekPlaceholder?: RangePlaceholder;
+}
+export interface PickerLocale extends Locale, PlaceholderLocale {
+}
+declare module "../../ConfigProvider" {
+    interface Locale {
+        Picker: PickerLocale;
+    }
+}
+export {};

package/dist/components/InternalPicker/index.d.ts

@@ -0,0 +1,4 @@
+export { SinglePicker, RangePicker, type SinglePickerProps, type RangePickerProps, } from './pickers';
+export type { PickerTokens } from './tokens';
+export { getPopupStyle, getSingleSelectorStyle, getRangeSelectorStyle, prefixCls } from './styles';
+export type { PickerLocale } from './config';

package/dist/components/InternalPicker/pickers/RangePicker/RangePicker.d.ts

@@ -0,0 +1,4 @@
+import { ForwardRefExoticComponent, MemoExoticComponent, RefAttributes } from 'react';
+import { RangePickerProps } from './RangePicker.types';
+import { RangePickerRef } from 'rc-picker/lib/interface';
+export declare const RangePicker: MemoExoticComponent<ForwardRefExoticComponent<RangePickerProps & RefAttributes<RangePickerRef>>>;

package/dist/components/InternalPicker/pickers/RangePicker/RangePicker.js

@@ -0,0 +1,49 @@
+import { jsx } from "@emotion/react/jsx-runtime";
+import { forwardRef, memo } from "react";
+import { RangePicker as RangePicker$1 } from "rc-picker";
+import { ClassNames } from "@emotion/react";
+import { getPickerTokens } from "../../tokens.js";
+import { SwapRightOutlined } from "@infomaximum/icons";
+import { getPopupStyle } from "../../styles/Popup.styles.js";
+import { getRangeSelectorStyle } from "../../styles/RangeSelector.styles.js";
+import dayjs from "dayjs";
+import { getFormatByPicker, defaultProps } from "../SinglePicker/SinglePicker.utils.js";
+import { getRangePlaceholder } from "./RangePicker.utils.js";
+import { useTheme } from "../../../../hooks/useTheme/useTheme.js";
+import { useConfig } from "../../../ConfigProvider/hooks/useConfig/useConfig.js";
+import { useComponents } from "../hooks/useComponents/useComponents.js";
+import { prefixCls } from "../../styles/common.styles.js";
+dayjs.locale("ru");
+const defaultSeparator = /* @__PURE__ */ jsx("span", { "aria-label": "to", className: `${prefixCls}-separator`, children: /* @__PURE__ */ jsx(SwapRightOutlined, {}) });
+const RangePickerComponent = forwardRef((props, ref) => {
+  const {
+    components: componentsProp,
+    placeholder,
+    ...rest
+  } = props;
+  const theme = useTheme();
+  const pickerTokens = getPickerTokens(theme);
+  const {
+    locale
+  } = useConfig("Picker");
+  const {
+    components
+  } = useComponents({
+    components: componentsProp
+  });
+  return /* @__PURE__ */ jsx(ClassNames, { children: ({
+    css,
+    cx
+  }) => {
+    var _a;
+    return /* @__PURE__ */ jsx(RangePicker$1, { ref, locale, placeholder: getRangePlaceholder(locale, rest.picker, placeholder), separator: defaultSeparator, format: getFormatByPicker(rest.picker, Boolean(rest.showTime)), ...defaultProps, ...rest, components, prefixCls, className: cx(css(getRangeSelectorStyle(pickerTokens)(theme)), {
+      [`${prefixCls}-error-status`]: rest.status === "error"
+    }, rest.className), classNames: {
+      popup: cx(css(getPopupStyle(pickerTokens)(theme)), (_a = rest.classNames) == null ? void 0 : _a.popup)
+    } });
+  } });
+});
+const RangePicker = memo(RangePickerComponent);
+export {
+  RangePicker
+};

package/dist/components/InternalPicker/pickers/RangePicker/RangePicker.types.d.ts

@@ -0,0 +1,8 @@
+import { Dayjs } from 'dayjs';
+import { RangePickerProps as RcRangePickerProps } from 'rc-picker';
+import { Placement } from '../SinglePicker/SinglePicker.types';
+export interface RangePickerProps extends Omit<RcRangePickerProps<Dayjs>, "prefixCls" | "locale" | "generateConfig" | "placement" | "placeholder">, Partial<Pick<RcRangePickerProps<Dayjs>, "locale" | "generateConfig">> {
+    status?: "error";
+    placement?: Placement;
+    placeholder?: RcRangePickerProps<Dayjs>["placeholder"] | null;
+}

package/dist/components/InternalPicker/pickers/RangePicker/RangePicker.utils.d.ts

@@ -0,0 +1,3 @@
+import { RangePickerProps } from './RangePicker.types';
+import { PickerLocale } from '../../config';
+export declare const getRangePlaceholder: (locale: PickerLocale, picker: RangePickerProps["picker"], placeholder: RangePickerProps["placeholder"]) => [string, string] | undefined;

package/dist/components/InternalPicker/pickers/RangePicker/RangePicker.utils.js

@@ -0,0 +1,13 @@
+import { isNull, capitalize } from "lodash-es";
+const getRangePlaceholder = (locale, picker, placeholder) => {
+  if (placeholder) {
+    return placeholder;
+  }
+  if (isNull(placeholder) || !picker) {
+    return;
+  }
+  return locale[`range${capitalize(picker)}Placeholder`];
+};
+export {
+  getRangePlaceholder
+};

package/dist/components/InternalPicker/pickers/RangePicker/index.d.ts

@@ -0,0 +1,2 @@
+export { RangePicker } from './RangePicker';
+export type { RangePickerProps } from './RangePicker.types';

package/dist/components/InternalPicker/pickers/SinglePicker/SinglePicker.d.ts

@@ -0,0 +1,4 @@
+import { ForwardRefExoticComponent, MemoExoticComponent, RefAttributes } from 'react';
+import { SinglePickerProps } from './SinglePicker.types';
+import { PickerRef } from 'rc-picker';
+export declare const SinglePicker: MemoExoticComponent<ForwardRefExoticComponent<SinglePickerProps & RefAttributes<PickerRef>>>;

package/dist/components/InternalPicker/pickers/SinglePicker/SinglePicker.js

@@ -0,0 +1,48 @@
+import { jsx } from "@emotion/react/jsx-runtime";
+import { forwardRef, memo } from "react";
+import { Picker } from "rc-picker";
+import { ClassNames } from "@emotion/react";
+import { getPickerTokens } from "../../tokens.js";
+import "../../../../configure/dayjs.js";
+import "@infomaximum/icons";
+import { getPopupStyle } from "../../styles/Popup.styles.js";
+import { getSingleSelectorStyle } from "../../styles/SingleSelector.styles.js";
+import dayjs from "dayjs";
+import { getSinglePlaceholder, getFormatByPicker, defaultProps } from "./SinglePicker.utils.js";
+import { useTheme } from "../../../../hooks/useTheme/useTheme.js";
+import { useConfig } from "../../../ConfigProvider/hooks/useConfig/useConfig.js";
+import { useComponents } from "../hooks/useComponents/useComponents.js";
+import { prefixCls } from "../../styles/common.styles.js";
+dayjs.locale("ru");
+const SinglePickerComponent = forwardRef((props, ref) => {
+  const {
+    components: componentsProp,
+    placeholder,
+    ...rest
+  } = props;
+  const theme = useTheme();
+  const pickerTokens = getPickerTokens(theme);
+  const {
+    locale
+  } = useConfig("Picker");
+  const {
+    components
+  } = useComponents({
+    components: componentsProp
+  });
+  return /* @__PURE__ */ jsx(ClassNames, { children: ({
+    css,
+    cx
+  }) => {
+    var _a;
+    return /* @__PURE__ */ jsx(Picker, { ref, locale, placeholder: getSinglePlaceholder(locale, rest.picker, placeholder), format: getFormatByPicker(rest.picker, Boolean(rest.showTime)), ...defaultProps, ...rest, components, prefixCls, className: cx(css(getSingleSelectorStyle(pickerTokens)(theme)), {
+      [`${prefixCls}-error-status`]: rest.status === "error"
+    }, rest.className), classNames: {
+      popup: cx(css(getPopupStyle(pickerTokens)(theme)), (_a = rest.classNames) == null ? void 0 : _a.popup)
+    } });
+  } });
+});
+const SinglePicker = memo(SinglePickerComponent);
+export {
+  SinglePicker
+};

package/dist/components/InternalPicker/pickers/SinglePicker/SinglePicker.types.d.ts

@@ -0,0 +1,9 @@
+import { Dayjs } from 'dayjs';
+import { PickerProps as RcSinglePickerProps } from 'rc-picker';
+export type Placement = "bottomLeft" | "bottomRight" | "topLeft" | "topRight";
+export interface SinglePickerProps extends Omit<RcSinglePickerProps<Dayjs>, "prefixCls" | "locale" | "generateConfig" | "placement" | "placeholder">, Partial<Pick<RcSinglePickerProps<Dayjs>, "locale" | "generateConfig">> {
+    status?: "error";
+    placement?: Placement;
+    placeholder?: RcSinglePickerProps<Dayjs>["placeholder"] | null;
+}
+export type LocaleMapObject = Record<string, string>;

package/dist/components/InternalPicker/pickers/SinglePicker/SinglePicker.utils.d.ts

@@ -0,0 +1,21 @@
+import { Dayjs } from 'dayjs';
+import { GenerateConfig } from 'rc-picker/lib/generate';
+import { Locale } from 'rc-picker/lib/interface';
+import { SinglePickerProps } from './SinglePicker.types';
+import { PickerLocale } from '../../config';
+export declare const defaultProps: {
+    allowClear: {
+        clearIcon: import("@emotion/react/jsx-runtime").JSX.Element;
+    };
+    generateConfig: GenerateConfig<Dayjs>;
+};
+export declare const quarterFormats: Partial<Locale>;
+export declare const defaultFormats: {
+    dateTime: string;
+    date: string;
+    week: string;
+    month: string;
+    quarter: string;
+};
+export declare const getFormatByPicker: (picker: SinglePickerProps["picker"], showTime: boolean) => string | undefined;
+export declare const getSinglePlaceholder: (locale: PickerLocale, picker: SinglePickerProps["picker"], placeholder: SinglePickerProps["placeholder"]) => string | undefined;