naive-ui 2.41.0 → 2.42.0

package/es/input-otp/src/InputOtp.mjs

@@ -0,0 +1,322 @@
+var __rest = this && this.__rest || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+import { pxfy, repeat } from 'seemly';
+import { useMergedState } from 'vooks';
+import { computed, defineComponent, h, ref, toRef } from 'vue';
+import { useConfig, useFormItem, useRtl, useTheme, useThemeClass } from "../../_mixins/index.mjs";
+import { call, createKey, isArrayShallowEqual, resolveSlotWithTypedProps } from "../../_utils/index.mjs";
+import { NInput } from "../../input/index.mjs";
+import inputOtpLight from "../styles/light.mjs";
+import style from "./styles/index.cssr.mjs";
+export const inputOtpProps = Object.assign(Object.assign({}, useTheme.props), {
+  defaultValue: {
+    type: Array,
+    default: []
+  },
+  value: Array,
+  length: {
+    type: Number,
+    default: 6
+  },
+  block: Boolean,
+  size: String,
+  disabled: Boolean,
+  mask: Boolean,
+  readonly: Boolean,
+  status: String,
+  gap: [String, Number],
+  placeholder: {
+    type: String,
+    default: ''
+  },
+  allowInput: Function,
+  onBlur: [Function, Array],
+  onFocus: [Function, Array],
+  'onUpdate:value': [Function, Array],
+  onUpdateValue: [Function, Array],
+  onFinish: [Function, Array]
+});
+export default defineComponent({
+  name: 'InputOtp',
+  props: inputOtpProps,
+  slots: Object,
+  setup(props) {
+    const {
+      mergedClsPrefixRef,
+      mergedRtlRef,
+      inlineThemeDisabled
+    } = useConfig(props);
+    const themeRef = useTheme('InputOtp', '-input-otp', style, inputOtpLight, props, mergedClsPrefixRef);
+    const rtlEnabledRef = useRtl('InputOtp', mergedRtlRef, mergedClsPrefixRef);
+    // form-item
+    const formItem = useFormItem(props);
+    const {
+      mergedSizeRef,
+      mergedDisabledRef,
+      mergedStatusRef
+    } = formItem;
+    const cssVarsRef = computed(() => {
+      const {
+        value: size
+      } = mergedSizeRef;
+      const {
+        gap: propGap
+      } = props;
+      const {
+        self: {
+          [createKey('inputWidth', size)]: inputWidth,
+          [createKey('gap', size)]: gap
+        }
+      } = themeRef.value;
+      return {
+        '--n-gap': propGap === undefined ? gap : typeof propGap === 'number' ? pxfy(propGap) : propGap,
+        '--n-input-width': inputWidth
+      };
+    });
+    const themeClassHandle = inlineThemeDisabled ? useThemeClass('input-otp', computed(() => {
+      const {
+        value: size
+      } = mergedSizeRef;
+      return size[0];
+    }), cssVarsRef, props) : undefined;
+    const uncontrolledValueRef = ref(props.defaultValue);
+    const controlledValueRef = toRef(props, 'value');
+    const mergedValueRef = useMergedState(controlledValueRef, uncontrolledValueRef);
+    const inputRefList = ref([]);
+    const inputTypeRef = computed(() => props.mask ? 'password' : 'text');
+    const handleFocus = (e, index) => {
+      // If it's focused from other input element inside the component, returns
+      if (inputRefList === null || inputRefList === void 0 ? void 0 : inputRefList.value.some(inputInst => inputInst.inputElRef === e.relatedTarget)) {
+        return;
+      }
+      const {
+        onFocus
+      } = props;
+      if (onFocus) {
+        call(onFocus, e, index);
+      }
+      const {
+        nTriggerFormFocus
+      } = formItem;
+      nTriggerFormFocus();
+    };
+    const handleBlur = (e, index) => {
+      // If it's blured to other input element inside the component, returns
+      if (inputRefList === null || inputRefList === void 0 ? void 0 : inputRefList.value.some(inputInst => inputInst.inputElRef === e.relatedTarget)) {
+        return;
+      }
+      const {
+        onBlur
+      } = props;
+      const {
+        nTriggerFormBlur
+      } = formItem;
+      if (onBlur) call(onBlur, e, index);
+      nTriggerFormBlur();
+    };
+    const focusOnChar = charIndex => {
+      if (charIndex >= props.length) return;
+      if (charIndex < 0) return;
+      inputRefList === null || inputRefList === void 0 ? void 0 : inputRefList.value[charIndex].focus();
+      inputRefList === null || inputRefList === void 0 ? void 0 : inputRefList.value[charIndex].select();
+    };
+    const focusOnNextChar = currentIndex => {
+      if (currentIndex >= props.length - 1) {
+        return;
+      }
+      focusOnChar(currentIndex + 1);
+    };
+    const focusOnPrevChar = currentIndex => {
+      if (currentIndex <= 0) {
+        return;
+      }
+      focusOnChar(currentIndex - 1);
+    };
+    const justifyValue = value => {
+      const justifiedValue = value ? Array.from(value) : [];
+      const length = props.length;
+      while (justifiedValue.length > length) {
+        justifiedValue.pop();
+      }
+      while (justifiedValue.length < length) {
+        justifiedValue.push('');
+      }
+      return justifiedValue;
+    };
+    function doUpdateValue(value, meta) {
+      const {
+        nTriggerFormInput,
+        nTriggerFormChange
+      } = formItem;
+      if (isArrayShallowEqual(value, mergedValueRef.value)) {
+        nTriggerFormInput();
+        return;
+      }
+      const {
+        'onUpdate:value': _onUpdateValue,
+        onUpdateValue,
+        length,
+        onFinish
+      } = props;
+      if (_onUpdateValue) call(_onUpdateValue, value, meta);
+      if (onUpdateValue) call(onUpdateValue, value, meta);
+      if (value.filter(v => v).length === length && onFinish) {
+        call(onFinish, value);
+      }
+      uncontrolledValueRef.value = value;
+      nTriggerFormInput();
+      nTriggerFormChange();
+    }
+    const handlePaste = (e, index) => {
+      if (props.readonly || mergedDisabledRef.value) {
+        return;
+      }
+      e.preventDefault();
+      const {
+        clipboardData
+      } = e;
+      const text = clipboardData === null || clipboardData === void 0 ? void 0 : clipboardData.getData('text');
+      if (!text) return;
+      const currentValue = justifyValue(mergedValueRef.value);
+      let startIndex = index;
+      const allowInput = props.allowInput;
+      let pasteApplied = false;
+      let appendedText = '';
+      for (let i = 0; i < text.length; ++i) {
+        if (allowInput && !allowInput(text[i], startIndex, currentValue)) {
+          continue;
+        }
+        pasteApplied = true;
+        currentValue[startIndex] = text[i];
+        appendedText += text[i];
+        startIndex++;
+        if (startIndex >= currentValue.length) {
+          break;
+        }
+      }
+      if (pasteApplied) {
+        focusOnChar(startIndex);
+        doUpdateValue(currentValue, {
+          diff: appendedText,
+          index: startIndex,
+          source: 'paste'
+        });
+      }
+    };
+    const handleKeydown = (e, index) => {
+      if (mergedDisabledRef.value) return;
+      const keyCode = e.code || e.key;
+      const currentValue = justifyValue(mergedValueRef.value);
+      if (keyCode === 'Backspace' && !props.readonly) {
+        e.preventDefault();
+        currentValue[Math.max(index, 0)] = '';
+        doUpdateValue(currentValue, {
+          diff: '',
+          index,
+          source: 'delete'
+        });
+        focusOnPrevChar(index);
+      } else if (keyCode === 'ArrowLeft') {
+        e.preventDefault();
+        focusOnPrevChar(index);
+      } else if (keyCode === 'ArrowRight') {
+        e.preventDefault();
+        focusOnNextChar(index);
+      }
+    };
+    const handleInput = (value, index) => {
+      const currentValue = justifyValue(mergedValueRef.value);
+      const currentValueAtIndex = currentValue[index];
+      const diff = value.replace(currentValueAtIndex, '');
+      const char = diff[diff.length - 1] || value[value.length - 1] || '';
+      const allowInput = props.allowInput;
+      if (allowInput && !allowInput(char, index, currentValue)) {
+        return;
+      }
+      currentValue[index] = char;
+      doUpdateValue(currentValue, {
+        diff: char,
+        index,
+        source: 'input'
+      });
+      focusOnNextChar(index);
+    };
+    const getTemplateEvents = index => {
+      return {
+        onInput: value => handleInput(value, index),
+        onPaste: event => handlePaste(event, index),
+        onKeydown: event => handleKeydown(event, index),
+        onFocus: event => handleFocus(event, index),
+        onBlur: event => handleBlur(event, index)
+      };
+    };
+    return {
+      mergedTheme: themeRef,
+      perItemValueArray: computed(() => justifyValue(mergedValueRef.value)),
+      mergedClsPrefix: mergedClsPrefixRef,
+      inputRefList,
+      inputType: inputTypeRef,
+      rtlEnabled: rtlEnabledRef,
+      mergedStatus: mergedStatusRef,
+      mergedDisabled: mergedDisabledRef,
+      cssVars: inlineThemeDisabled ? undefined : cssVarsRef,
+      themeClass: themeClassHandle === null || themeClassHandle === void 0 ? void 0 : themeClassHandle.themeClass,
+      getTemplateEvents,
+      onRender: themeClassHandle === null || themeClassHandle === void 0 ? void 0 : themeClassHandle.onRender
+    };
+  },
+  render() {
+    const {
+      mergedTheme,
+      mergedClsPrefix,
+      perItemValueArray,
+      size,
+      placeholder,
+      mergedDisabled,
+      mergedStatus,
+      readonly,
+      inputType,
+      $slots,
+      getTemplateEvents,
+      themeClass,
+      onRender
+    } = this;
+    onRender === null || onRender === void 0 ? void 0 : onRender();
+    return h("div", {
+      style: this.cssVars,
+      class: [`${mergedClsPrefix}-input-otp`, themeClass, this.rtlEnabled && `${mergedClsPrefix}-input-otp--rtl`, this.block && `${mergedClsPrefix}-input-otp--block`]
+    }, repeat(this.length, undefined).map((_, index) => resolveSlotWithTypedProps($slots.default, Object.assign({
+      index,
+      value: perItemValueArray[index],
+      type: inputType,
+      size,
+      placeholder,
+      disabled: mergedDisabled,
+      readonly,
+      status: mergedStatus,
+      builtinThemeOverrides: {
+        paddingTiny: '0',
+        paddingSmall: '0',
+        paddingMedium: '0',
+        paddingLarge: '0'
+      },
+      theme: mergedTheme.peers.Input,
+      themeOverrides: mergedTheme.peerOverrides.Input,
+      ref: el => this.inputRefList[index] = el
+    }, getTemplateEvents(index)), _a => {
+      var {
+          index
+        } = _a,
+        restProps = __rest(_a, ["index"]);
+      return [h(NInput, Object.assign({}, restProps, {
+        key: index
+      }))];
+    })));
+  }
+});

package/es/input-otp/src/public-types.d.ts

@@ -0,0 +1,24 @@
+import type { VNode } from 'vue';
+import type { InputInst } from '../../components';
+import type { InputProps } from '../../input/src/Input';
+export type InputOtpAllowInput = (char: string, index: number, currentValue: string[]) => boolean;
+export type InputOtpSize = 'small' | 'medium' | 'large';
+export type InputOtpOnUpdateValue = (value: string[], meta: InputOtpOnUpdateValueMeta) => void;
+export type InputOtpOnFocus = (e: FocusEvent, index: number) => void;
+export type InputOtpOnBlur = (e: FocusEvent, index: number) => void;
+export interface InputOtpSlots {
+    default?: InputOtpDefaultSlot;
+}
+export type InputOtpDefaultSlot = (props: InputProps & {
+    index: number;
+    ref: (inst: InputInst) => void;
+}) => VNode[];
+export type InputOtpOnFinish = (value: string[]) => void;
+export interface InputOtpOnUpdateValueMeta {
+    diff: string;
+    index: number;
+    source: InputOtpOnUpdateValueMetaSource;
+}
+export type InputOtpOnUpdateValueMetaSource = 'paste' | 'input' | 'delete';
+export interface InputOtpInst {
+}

package/es/input-otp/src/public-types.mjs

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

package/es/input-otp/src/styles/index.cssr.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("css-render").CNode;
+export default _default;

package/es/input-otp/src/styles/index.cssr.mjs

@@ -0,0 +1,20 @@
+import { c, cB, cM, cNotM } from "../../../_utils/cssr/index.mjs";
+// --n-input-width
+// --n-gap
+export default c([cB('input-otp', `
+ display: flex;
+ align-items: center;
+ gap: var(--n-gap);
+ `, [cM('block', ``, [cB('input', ``, [cNotM('autosize', `
+ text-align: center;
+ min-width: 0;
+ `), cM('autosize', `
+ text-align: center;
+ min-width: 0;
+ `)])]), cNotM('block', ``, [cB('input', ``, [cNotM('autosize', `
+ width: var(--n-input-width);
+ text-align: center;
+ `), cM('autosize', `
+ width: var(--n-input-width);
+ text-align: center;
+ `)])])])]);

package/es/input-otp/src/styles/input-otp-rtl.cssr.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("css-render").CNode;
+export default _default;

package/es/input-otp/src/styles/input-otp-rtl.cssr.mjs

@@ -0,0 +1,5 @@
+import { cB, cM } from "../../../_utils/cssr/index.mjs";
+// --n-gap
+export default cB('input-otp', [cM('rtl', `
+ direction: rtl;
+ `)]);

package/es/input-otp/styles/dark.d.ts

@@ -0,0 +1,3 @@
+import type { InputOtpTheme } from './light';
+declare const inputOtpDark: InputOtpTheme;
+export default inputOtpDark;

package/es/input-otp/styles/dark.mjs

@@ -0,0 +1,12 @@
+import { commonDark } from "../../_styles/common/index.mjs";
+import { inputDark } from "../../styles.mjs";
+import { self } from "./light.mjs";
+const inputOtpDark = {
+  name: 'InputOtp',
+  common: commonDark,
+  peers: {
+    Input: inputDark
+  },
+  self
+};
+export default inputOtpDark;

package/es/input-otp/styles/index.d.ts

@@ -0,0 +1,4 @@
+export { default as inputOtpDark } from './dark';
+export { default as inputOtpLight } from './light';
+export type { InputOtpTheme } from './light';
+export { inputOtpRtl } from './rtl';

package/es/input-otp/styles/index.mjs

@@ -0,0 +1,3 @@
+export { default as inputOtpDark } from "./dark.mjs";
+export { default as inputOtpLight } from "./light.mjs";
+export { inputOtpRtl } from "./rtl.mjs";

package/es/input-otp/styles/light.d.ts

@@ -0,0 +1,81 @@
+export declare function self(): {
+    inputWidthSmall: string;
+    inputWidthMedium: string;
+    inputWidthLarge: string;
+    gapSmall: string;
+    gapMedium: string;
+    gapLarge: string;
+};
+declare const inputOtpLight: import("../../_mixins").Theme<"InputOtp", {
+    inputWidthSmall: string;
+    inputWidthMedium: string;
+    inputWidthLarge: string;
+    gapSmall: string;
+    gapMedium: string;
+    gapLarge: string;
+}, {
+    Input: import("../../_mixins").Theme<"Input", {
+        fontWeight: string;
+        countTextColorDisabled: string;
+        countTextColor: string;
+        heightTiny: string;
+        heightSmall: string;
+        heightMedium: string;
+        heightLarge: string;
+        fontSizeTiny: string;
+        fontSizeSmall: string;
+        fontSizeMedium: string;
+        fontSizeLarge: string;
+        lineHeight: string;
+        lineHeightTextarea: string;
+        borderRadius: string;
+        iconSize: string;
+        groupLabelColor: string;
+        groupLabelTextColor: string;
+        textColor: string;
+        textColorDisabled: string;
+        textDecorationColor: string;
+        caretColor: string;
+        placeholderColor: string;
+        placeholderColorDisabled: string;
+        color: string;
+        colorDisabled: string;
+        colorFocus: string;
+        groupLabelBorder: string;
+        border: string;
+        borderHover: string;
+        borderDisabled: string;
+        borderFocus: string;
+        boxShadowFocus: string;
+        loadingColor: string;
+        loadingColorWarning: string;
+        borderWarning: string;
+        borderHoverWarning: string;
+        colorFocusWarning: string;
+        borderFocusWarning: string;
+        boxShadowFocusWarning: string;
+        caretColorWarning: string;
+        loadingColorError: string;
+        borderError: string;
+        borderHoverError: string;
+        colorFocusError: string;
+        borderFocusError: string;
+        boxShadowFocusError: string;
+        caretColorError: string;
+        clearColor: string;
+        clearColorHover: string;
+        clearColorPressed: string;
+        iconColor: string;
+        iconColorDisabled: string;
+        iconColorHover: string;
+        iconColorPressed: string;
+        suffixTextColor: string;
+        paddingTiny: string;
+        paddingSmall: string;
+        paddingMedium: string;
+        paddingLarge: string;
+        clearSize: string;
+    }, any>;
+}>;
+export default inputOtpLight;
+export type InputOtpTheme = typeof inputOtpLight;

package/es/input-otp/styles/light.mjs

@@ -0,0 +1,22 @@
+import { createTheme } from "../../_mixins/index.mjs";
+import { commonLight } from "../../_styles/common/index.mjs";
+import { inputLight } from "../../input/styles/index.mjs";
+export function self() {
+  return {
+    inputWidthSmall: '24px',
+    inputWidthMedium: '30px',
+    inputWidthLarge: '36px',
+    gapSmall: '8px',
+    gapMedium: '8px',
+    gapLarge: '8px'
+  };
+}
+const inputOtpLight = createTheme({
+  name: 'InputOtp',
+  common: commonLight,
+  peers: {
+    Input: inputLight
+  },
+  self
+});
+export default inputOtpLight;

package/es/input-otp/styles/rtl.d.ts

@@ -0,0 +1,2 @@
+import type { RtlItem } from '../../config-provider/src/internal-interface';
+export declare const inputOtpRtl: RtlItem;

package/es/input-otp/styles/rtl.mjs

@@ -0,0 +1,5 @@
+import rtlStyle from "../src/styles/input-otp-rtl.cssr.mjs";
+export const inputOtpRtl = {
+  name: 'InputOtp',
+  style: rtlStyle
+};

package/es/mention/src/Mention.d.ts

@@ -1,6 +1,6 @@
 import type { RenderLabel } from '../../_internal/select-menu/src/interface';
 import type { ExtractPublicPropTypes, MaybeArray } from '../../_utils';
-import type { FormValidationStatus } from '../../form/src/interface';
+import type { FormValidationStatus } from '../../form/src/public-types';
 import type { Size as InputSize } from '../../input/src/interface';
 import type { SelectBaseOption, SelectGroupOption, SelectIgnoredOption } from '../../select/src/interface';
 import type { MentionOption } from './interface';

package/es/progress/src/Circle.d.ts

@@ -85,8 +85,8 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         default: number;
     };
 }>> & Readonly<{}>, {
+    gapOffsetDegree: number;
     percentage: number;
     offsetDegree: number;
-    gapOffsetDegree: number;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/es/progress/src/MultipleCircle.d.ts

@@ -77,7 +77,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
 }>> & Readonly<{}>, {
     railColor: string[];
     fillColor: string[] | ProgressGradient[];
-    percentage: number[];
     railStyle: (string | CSSProperties)[];
+    percentage: number[];
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/es/progress/src/Progress.d.ts

@@ -385,10 +385,10 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     readonly strokeWidth: number;
     readonly unit: string;
     readonly processing: boolean;
-    readonly showIndicator: boolean;
     readonly viewBoxWidth: number;
+    readonly showIndicator: boolean;
+    readonly indicatorPosition: "inside" | "outside";
     readonly indicatorPlacement: "inside" | "outside";
     readonly circleGap: number;
-    readonly indicatorPosition: "inside" | "outside";
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/es/radio/src/Radio.mjs

@@ -88,7 +88,11 @@ export default defineComponent({
     return h("label", {
       class: [`${mergedClsPrefix}-radio`, this.themeClass, this.rtlEnabled && `${mergedClsPrefix}-radio--rtl`, this.mergedDisabled && `${mergedClsPrefix}-radio--disabled`, this.renderSafeChecked && `${mergedClsPrefix}-radio--checked`, this.focus && `${mergedClsPrefix}-radio--focus`],
       style: this.cssVars
-    }, h("input", {
+    }, h("div", {
+      class: `${mergedClsPrefix}-radio__dot-wrapper`
+    }, "\u00A0", h("div", {
+      class: [`${mergedClsPrefix}-radio__dot`, this.renderSafeChecked && `${mergedClsPrefix}-radio__dot--checked`]
+    }), h("input", {
       ref: "inputRef",
       type: "radio",
       class: `${mergedClsPrefix}-radio-input`,
@@ -99,10 +103,6 @@ export default defineComponent({
       onChange: this.handleRadioInputChange,
       onFocus: this.handleRadioInputFocus,
       onBlur: this.handleRadioInputBlur
-    }), h("div", {
-      class: `${mergedClsPrefix}-radio__dot-wrapper`
-    }, "\u00A0", h("div", {
-      class: [`${mergedClsPrefix}-radio__dot`, this.renderSafeChecked && `${mergedClsPrefix}-radio__dot--checked`]
     })), resolveWrappedSlot($slots.default, children => {
       if (!children && !label) return null;
       return h("div", {

package/es/radio/src/styles/radio.cssr.mjs

@@ -38,14 +38,10 @@ export default cB('radio', `
  `), cB('radio-input', `
  position: absolute;
  border: 0;
- border-radius: inherit;
- left: 0;
- right: 0;
- top: 0;
- bottom: 0;
+ width: 0;
+ height: 0;
  opacity: 0;
- z-index: 1;
- cursor: pointer;
+ margin: 0;
  `), cE('dot', `
  position: absolute;
  top: 50%;

package/es/select/src/Select.d.ts

@@ -1,7 +1,7 @@
 import type { NodeProps, RenderLabel, RenderOption } from '../../_internal/select-menu/src/interface';
 import type { RenderTag } from '../../_internal/selection/src/interface';
 import type { ExtractPublicPropTypes, MaybeArray } from '../../_utils';
-import type { FormValidationStatus } from '../../form/src/interface';
+import type { FormValidationStatus } from '../../form/src/public-types';
 import type { PopoverProps } from '../../popover';
 import type { OnUpdateValue, SelectBaseOption, SelectFallbackOption, SelectFilter, SelectGroupOption, SelectIgnoredOption, SelectMixedOption, SelectOption, Size, Value, ValueAtom } from './interface';
 import { type TreeNode } from 'treemate';

package/es/styles.d.ts

@@ -36,6 +36,7 @@ export { formDark } from './form/styles';
 export { gradientTextDark } from './gradient-text/styles';
 export { iconDark } from './icon/styles';
 export { inputNumberDark, inputNumberRtl as unstableInputNumberRtl } from './input-number/styles';
+export { inputOtpDark, inputOtpRtl as unstableInputOtpRtl } from './input-otp/styles';
 export { inputDark, inputRtl as unstableInputRtl } from './input/styles';
 export { layoutDark } from './layout/styles';
 export { rowRtl as unstableRowRtl } from './legacy-grid/styles';

package/es/styles.mjs

@@ -37,6 +37,7 @@ export { formDark } from "./form/styles/index.mjs";
 export { gradientTextDark } from "./gradient-text/styles/index.mjs";
 export { iconDark } from "./icon/styles/index.mjs";
 export { inputNumberDark, inputNumberRtl as unstableInputNumberRtl } from "./input-number/styles/index.mjs";
+export { inputOtpDark, inputOtpRtl as unstableInputOtpRtl } from "./input-otp/styles/index.mjs";
 export { inputDark, inputRtl as unstableInputRtl } from "./input/styles/index.mjs";
 export { layoutDark } from "./layout/styles/index.mjs";
 export { rowRtl as unstableRowRtl } from "./legacy-grid/styles/index.mjs";

package/es/tabs/src/TabPane.d.ts

@@ -22,6 +22,7 @@ export declare const tabPaneProps: {
 export type TabPaneProps = ExtractPublicPropTypes<typeof tabPaneProps>;
 export interface TabPaneSlots {
     default?: () => VNode[];
+    tab?: () => VNode[];
     prefix?: () => VNode[];
     suffix?: () => VNode[];
 }

package/es/themes/dark.mjs

@@ -71,7 +71,7 @@ import { spinDark } from "../spin/styles/index.mjs";
 import { splitDark } from "../split/styles/index.mjs";
 import { statisticDark } from "../statistic/styles/index.mjs";
 import { stepsDark } from "../steps/styles/index.mjs";
-import { flexDark } from "../styles.mjs";
+import { flexDark, inputOtpDark } from "../styles.mjs";
 import { switchDark } from "../switch/styles/index.mjs";
 import { tableDark } from "../table/styles/index.mjs";
 import { tabsDark } from "../tabs/styles/index.mjs";
@@ -129,6 +129,7 @@ export const darkTheme = {
   Image: imageDark,
   Input: inputDark,
   InputNumber: inputNumberDark,
+  InputOtp: inputOtpDark,
   LegacyTransfer: legacyTransferDark,
   Layout: layoutDark,
   List: listDark,