tanxin-ui 0.2.0

package/es/color-picker/src/color-picker.d.ts

@@ -0,0 +1,133 @@
+import type { PropType } from 'vue';
+declare const _default: import("vue").DefineComponent<{
+    size: import("vue-types").VueTypeDef<string> & {
+        default: string;
+    };
+    alpha: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    readonly: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    format: {
+        type: PropType<"HEX | RGB | HSL |HSV"[]>;
+        default: () => string[];
+    };
+    disabled: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    loading: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    value: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    clearable: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    palette: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    history: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    selection: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    selectionList: {
+        type: PropType<string[]>;
+        default: () => any[];
+    };
+}, {
+    refInput: import("vue").Ref<any>;
+    render: () => JSX.Element;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "clear" | "update:value")[], "change" | "clear" | "update:value", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    size: import("vue-types").VueTypeDef<string> & {
+        default: string;
+    };
+    alpha: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    readonly: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    format: {
+        type: PropType<"HEX | RGB | HSL |HSV"[]>;
+        default: () => string[];
+    };
+    disabled: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    loading: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    value: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    clearable: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    palette: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    history: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    selection: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    selectionList: {
+        type: PropType<string[]>;
+        default: () => any[];
+    };
+}>> & {
+    onChange?: (...args: any[]) => any;
+    "onUpdate:value"?: (...args: any[]) => any;
+    onClear?: (...args: any[]) => any;
+}, {
+    disabled: boolean;
+    size: string;
+    alpha: boolean;
+    value: string;
+    loading: boolean;
+    format: "HEX | RGB | HSL |HSV"[];
+    readonly: boolean;
+    clearable: boolean;
+    palette: boolean;
+    history: boolean;
+    selection: boolean;
+    selectionList: string[];
+}>;
+export default _default;

package/es/color-picker/src/color-picker.js

@@ -0,0 +1,262 @@
+import { defineComponent, ref, watch, computed, createVNode, mergeProps, resolveComponent, withDirectives, resolveDirective, Fragment } from "vue";
+import { PropTypes } from "../../utils/type.js";
+import { TPopper } from "../../popper/index.js";
+import ColorPickerContent from "./color-picker-content.js";
+import "../../utils/components/icons/Checkmark.js";
+import "../../utils/components/icons/CheckmarkCircle.js";
+import "../../utils/components/icons/CheckmarkSharp.js";
+import "../../utils/components/icons/CheckmarkCircleOutline.js";
+import "../../utils/components/icons/AlertCircle.js";
+import "../../utils/components/icons/AlertCircleOutline.js";
+import "../../utils/components/icons/InformationCircle.js";
+import "../../utils/components/icons/InformationCircleOutline.js";
+import "../../utils/components/icons/CloseCircle.js";
+import CloseCircleOutline from "../../utils/components/icons/CloseCircleOutline.js";
+import "../../utils/components/icons/HelpCircleSharp.js";
+import "../../utils/components/icons/EyeOffOutline.js";
+import "../../utils/components/icons/EyeOutline.js";
+import "../../utils/components/icons/LoadingOutlined.js";
+import Close from "../../utils/components/icons/Close.js";
+import "../../utils/components/icons/CloseOutline.js";
+import "../../utils/components/icons/ArrowsMaximize.js";
+import "../../utils/components/icons/ArrowsMinimize.js";
+import "../../utils/components/icons/AddOutline.js";
+import "../../utils/components/icons/RemoveOutline.js";
+import "../../utils/components/icons/ChevronUp.js";
+import ChevronDown from "../../utils/components/icons/ChevronDown.js";
+import "../../utils/components/icons/ChevronForward.js";
+import "../../utils/components/icons/ChevronLeft24Filled.js";
+import "../../utils/components/icons/ChevronRight24Filled.js";
+import "../../utils/components/icons/ChevronDoubleLeft16Filled.js";
+import "../../utils/components/icons/ChevronDoubleRight16Filled.js";
+import "../../utils/components/icons/CheckmarkOutline.js";
+import "../../utils/components/icons/IosCheckmark.js";
+import "../../utils/components/icons/Empty.js";
+import "../../utils/components/icons/Bars.js";
+import "../../utils/components/icons/ArrowUpCircle.js";
+import "../../utils/components/icons/ArrowUp.js";
+import "../../utils/components/icons/ArrowForward.js";
+import "../../utils/components/icons/TimeOutline.js";
+import "../../utils/components/icons/CalendarClearOutline.js";
+import "../../utils/components/icons/KeyboardArrowLeftRound.js";
+import "../../utils/components/icons/KeyboardArrowRightRound.js";
+import "../../utils/components/icons/KeyboardDoubleArrowLeftRound.js";
+import "../../utils/components/icons/KeyboardDoubleArrowRightRound.js";
+import "../../utils/components/icons/MenuFoldOutlined.js";
+import "../../utils/components/icons/IosArrowDown.js";
+import "../../utils/components/icons/IosArrowBack.js";
+import "../../utils/components/icons/IosArrowForward.js";
+import "../../utils/components/icons/ImageSharp.js";
+import "../../utils/components/icons/Pause.js";
+import "../../utils/components/icons/Refresh.js";
+import "../../utils/components/icons/QuestionCircle24Regular.js";
+import "../../utils/components/icons/CloudUploadOutline.js";
+import "../../utils/components/icons/UploadFileFilled.js";
+import "../../utils/components/icons/EllipsisHorizontal.js";
+import "../../utils/components/icons/ArrowNext24Filled.js";
+import "../../utils/components/icons/ArrowPrevious24Filled.js";
+import "../../utils/components/icons/ArrowDropDownSharp.js";
+import "../../utils/components/icons/ArrowDropUpSharp.js";
+import "../../utils/components/icons/ArrowForwardIosFilled.js";
+import { useConfig } from "../../utils/hooks/useConfig.js";
+import { directive } from "../../utils/directives/click-outside.js";
+import { provideColorPicker } from "./context.js";
+const colorPickerProps = {
+  size: PropTypes.oneOf(["xs", "sm", "md", "lg", "xl"]).def("md"),
+  alpha: PropTypes.bool.def(false),
+  readonly: PropTypes.bool.def(false),
+  format: {
+    type: Array,
+    default: () => ["HEX", "RGB", "HSL", "HSV"]
+  },
+  disabled: PropTypes.bool.def(false),
+  loading: PropTypes.bool.def(false),
+  value: PropTypes.string,
+  clearable: PropTypes.bool.def(true),
+  palette: PropTypes.bool.def(true),
+  history: PropTypes.bool.def(false),
+  selection: PropTypes.bool.def(false),
+  selectionList: {
+    type: Array,
+    default: () => []
+  }
+};
+var ColorPicker = defineComponent({
+  name: "TColorPicker",
+  components: {
+    TPopper,
+    CloseCircleOutline,
+    ChevronDown,
+    Close
+  },
+  directives: {
+    clickOutside: directive
+  },
+  inheritAttrs: false,
+  props: colorPickerProps,
+  emits: ["update:value", "clear", "change"],
+  setup(props, {
+    emit
+  }) {
+    const currentValue = ref(props.value);
+    const showClear = ref(false);
+    const {
+      prefixCls
+    } = useConfig("color-picker", props);
+    const refContent = ref();
+    const focusArr = [ref(), ref()];
+    const visible = ref(false);
+    const refInput = ref();
+    const isFocus = ref(false);
+    const refPopper = ref(null);
+    const refTrigger = ref(null);
+    const handleClickOutside = () => {
+      isFocus.value = false;
+    };
+    const handleClick = () => {
+      isFocus.value = true;
+    };
+    watch(() => props.value, () => {
+      currentValue.value = props.value;
+    }, {
+      deep: true
+    });
+    const emptyClick = (event) => {
+      event.stopPropagation();
+    };
+    const handleClearClick = (event) => {
+      currentValue.value = "";
+      emit("update:value", currentValue.value);
+      emit("change", currentValue.value);
+      emit("clear", event);
+    };
+    const close = () => {
+      visible.value = false;
+    };
+    const submit = (value) => {
+      currentValue.value = value;
+      emit("update:value", currentValue.value);
+      emit("change", currentValue.value);
+      close();
+    };
+    provideColorPicker({
+      visible: computed(() => visible.value),
+      close,
+      submit
+    });
+    const render = () => {
+      const contentProps = {
+        readonly: props.readonly,
+        value: props.value,
+        format: props.format,
+        alpha: props.alpha,
+        history: props.history,
+        selectionList: props.selectionList,
+        selection: props.selection,
+        palette: props.palette
+      };
+      const contentElement = createVNode(ColorPickerContent, mergeProps({
+        "ref": refContent
+      }, contentProps), null);
+      const inputProps = {
+        type: "text",
+        class: `${prefixCls.value}-input`,
+        onFocus: () => {
+          focusArr[0].value = true;
+          isFocus.value = true;
+        },
+        onBlur: () => {
+          if (!visible.value)
+            isFocus.value = false;
+          focusArr[0].value = false;
+        },
+        onClick: emptyClick
+      };
+      const triggerClasses = computed(() => {
+        const values = [`${prefixCls.value}-trigger`, {
+          [`is-focus`]: isFocus.value,
+          [`is-disabled`]: props.disabled || props.loading,
+          [`is-readonly`]: props.readonly,
+          [`is-open`]: visible.value,
+          [`size-${props.size}`]: props.size
+        }];
+        return values;
+      });
+      const triggerProps = {
+        ref: refTrigger
+      };
+      if (!props.disabled && props.clearable) {
+        triggerProps["onMouseenter"] = () => {
+          if (currentValue.value)
+            showClear.value = true;
+        };
+        triggerProps["onMouseleave"] = () => {
+          showClear.value = false;
+        };
+      }
+      const suffixElement = createVNode("span", {
+        "class": `${prefixCls.value}-suffix`
+      }, [showClear.value && !props.readonly && currentValue.value ? createVNode(resolveComponent("t-icon"), {
+        "class": "is-action",
+        "onClick": handleClearClick
+      }, {
+        default: () => [createVNode(CloseCircleOutline, null, null)]
+      }) : createVNode(resolveComponent("t-icon"), {
+        "class": "is-arrow"
+      }, {
+        default: () => [createVNode(ChevronDown, null, null)]
+      })]);
+      const colorBarStyles = computed(() => {
+        return {
+          backgroundColor: currentValue.value
+        };
+      });
+      const colorBarElement = createVNode("div", {
+        "class": `${prefixCls.value}-trigger-bar`,
+        "style": colorBarStyles.value
+      }, null);
+      const emptyElement = createVNode("div", {
+        "class": `${prefixCls.value}-trigger-bar`
+      }, [createVNode(resolveComponent("t-icon"), null, {
+        default: () => [createVNode(Close, null, null)]
+      })]);
+      const triggerElement = createVNode("label", null, [withDirectives(createVNode("div", null, [createVNode("div", mergeProps({
+        "class": triggerClasses.value
+      }, triggerProps), [currentValue.value ? colorBarElement : emptyElement, suffixElement]), createVNode("input", mergeProps({
+        "ref": refInput
+      }, inputProps, {
+        "inputmode": "none"
+      }), null)]), [[resolveDirective("clickOutside"), handleClickOutside]])]);
+      const inSlots = {
+        trigger: () => triggerElement,
+        content: () => contentElement
+      };
+      const popperProps = {
+        placement: "bottomLeft",
+        trigger: "click",
+        transitionName: "slide-up",
+        sameWidth: false,
+        isToggle: true,
+        disabled: props.disabled || props.readonly,
+        offset: 6,
+        showArrow: false
+      };
+      if (!props.disabled)
+        popperProps[`onClick`] = handleClick;
+      return createVNode(Fragment, null, [createVNode(resolveComponent("t-popper"), mergeProps({
+        "ref": refPopper,
+        "class": " is-color-picker",
+        "visible": visible.value,
+        "onUpdate:visible": ($event) => visible.value = $event
+      }, popperProps), inSlots)]);
+    };
+    return {
+      refInput,
+      render
+    };
+  },
+  render() {
+    return this.render();
+  }
+});
+export { ColorPicker as default };

package/es/color-picker/src/context.d.ts

@@ -0,0 +1,17 @@
+import type { InjectionKey, ComputedRef } from 'vue';
+export declare type ColorFormat = 'HEX | RGB | HSL |HSV';
+export interface ColorPickerContext {
+    visible: ComputedRef<boolean>;
+    close: () => void;
+    submit: (value: string) => void;
+}
+export interface Color {
+    h: number;
+    s: number;
+    v: number;
+    a: number;
+}
+export declare const ColorPickerContextKey: InjectionKey<ColorPickerContext>;
+declare const provideColorPicker: (data: ColorPickerContext) => void;
+declare const injectColorPicker: () => ColorPickerContext;
+export { injectColorPicker, provideColorPicker };

package/es/color-picker/src/context.js

@@ -0,0 +1,9 @@
+import { inject, provide } from "vue";
+const ColorPickerContextKey = Symbol("ColorPickerContextKey");
+const provideColorPicker = (data) => {
+  provide(ColorPickerContextKey, data);
+};
+const injectColorPicker = () => {
+  return inject(ColorPickerContextKey);
+};
+export { ColorPickerContextKey, injectColorPicker, provideColorPicker };

package/es/components.d.ts

@@ -0,0 +1,59 @@
+export * from './config-provider';
+export * from './icon';
+export * from './link';
+export * from './button';
+export * from './form';
+export * from './input';
+export * from './input-number';
+export * from './textarea';
+export * from './radio';
+export * from './checkbox';
+export * from './switch';
+export * from './select';
+export * from './cascader';
+export * from './tree-select';
+export * from './time-picker';
+export * from './date-picker';
+export * from './color-picker';
+export * from './slider';
+export * from './upload';
+export * from './popper';
+export * from './popover';
+export * from './tooltip';
+export * from './popconfirm';
+export * from './alert';
+export * from './message';
+export * from './notification';
+export * from './modal';
+export * from './message-box';
+export * from './drawer';
+export * from './loading';
+export * from './skeleton';
+export * from './status';
+export * from './progress';
+export * from './table';
+export * from './empty';
+export * from './avatar';
+export * from './badge';
+export * from './tag';
+export * from './tree';
+export * from './cascader-panel';
+export * from './calendar';
+export * from './carousel';
+export * from './affix';
+export * from './anchor';
+export * from './back-top';
+export * from './loading-bar';
+export * from './dropdown';
+export * from './menu';
+export * from './breadcrumb';
+export * from './tabs';
+export * from './steps';
+export * from './pagination';
+export * from './divider';
+export * from './layout';
+export * from './line-grid';
+export * from './grid';
+export * from './space';
+export * from './card';
+export * from './list';

package/es/components.js

@@ -0,0 +1,59 @@
+export { TConfigProvider } from "./config-provider/index.js";
+export { TIcon } from "./icon/index.js";
+export { TLink } from "./link/index.js";
+export { TButton } from "./button/index.js";
+export { TForm, TFormItem } from "./form/index.js";
+export { TInput } from "./input/index.js";
+export { TInputNumber } from "./input-number/index.js";
+export { TTextarea } from "./textarea/index.js";
+export { TRadio, TRadioGroup } from "./radio/index.js";
+export { TCheckbox, TCheckboxGroup } from "./checkbox/index.js";
+export { TSwitch } from "./switch/index.js";
+export { TSelect, TSelectGroup, TSelectOption } from "./select/index.js";
+export { TCascader } from "./cascader/index.js";
+export { TTreeSelect } from "./tree-select/index.js";
+export { TTimePicker } from "./time-picker/index.js";
+export { TDatePicker } from "./date-picker/index.js";
+export { TColorPicker } from "./color-picker/index.js";
+export { TSlider } from "./slider/index.js";
+export { TUpload } from "./upload/index.js";
+export { TPopper } from "./popper/index.js";
+export { TPopover } from "./popover/index.js";
+export { TTooltip } from "./tooltip/index.js";
+export { TPopconfirm } from "./popconfirm/index.js";
+export { TAlert } from "./alert/index.js";
+export { TMessage } from "./message/index.js";
+export { TNotification } from "./notification/index.js";
+export { TModal } from "./modal/index.js";
+export { TMessageBox } from "./message-box/index.js";
+export { TDrawer } from "./drawer/index.js";
+export { TLoading } from "./loading/index.js";
+export { TSkeleton, TSkeletonItem } from "./skeleton/index.js";
+export { TStatus } from "./status/index.js";
+export { TProgress } from "./progress/index.js";
+export { TTable } from "./table/index.js";
+export { TEmpty } from "./empty/index.js";
+export { TAvatar } from "./avatar/index.js";
+export { TBadge } from "./badge/index.js";
+export { TTag } from "./tag/index.js";
+export { TTree } from "./tree/index.js";
+export { TCascaderPanel } from "./cascader-panel/index.js";
+export { TCalendar } from "./calendar/index.js";
+export { TCarousel } from "./carousel/index.js";
+export { TAffix } from "./affix/index.js";
+export { TAnchor, TAnchorLink } from "./anchor/index.js";
+export { TBackTop } from "./back-top/index.js";
+export { TLoadingBar } from "./loading-bar/index.js";
+export { TDropdown, TDropdownGroup, TDropdownItem } from "./dropdown/index.js";
+export { TMenu, TMenuGroup, TMenuItem } from "./menu/index.js";
+export { TBreadcrumb, TBreadcrumbItem } from "./breadcrumb/index.js";
+export { TTab, TTabs } from "./tabs/index.js";
+export { TStep, TSteps } from "./steps/index.js";
+export { TPagination } from "./pagination/index.js";
+export { TDivider } from "./divider/index.js";
+export { TLayout, TLayoutContent, TLayoutFooter, TLayoutHeader, TLayoutSider } from "./layout/index.js";
+export { TCol, TFlex, TRow } from "./line-grid/index.js";
+export { TGrid, TGridCol } from "./grid/index.js";
+export { TSpace } from "./space/index.js";
+export { TCard } from "./card/index.js";
+export { TList, TListItem } from "./list/index.js";

package/es/config-provider/index.d.ts

@@ -0,0 +1,80 @@
+declare const TConfigProvider: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            rootPrefixCls: string;
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            rootPrefixCls: import("vue-types").VueTypeValidableDef<string> & {
+                default: string;
+            } & {
+                default: string;
+            };
+        }>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "rootPrefixCls">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot;
+        }>;
+        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
+        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            rootPrefixCls: import("vue-types").VueTypeValidableDef<string> & {
+                default: string;
+            } & {
+                default: string;
+            };
+        }>>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>[], unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, {
+            rootPrefixCls: string;
+        }> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch(source: string | Function, cb: Function, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
+    } & Readonly<import("vue").ExtractPropTypes<{
+        rootPrefixCls: import("vue-types").VueTypeValidableDef<string> & {
+            default: string;
+        } & {
+            default: string;
+        };
+    }>> & import("vue").ShallowUnwrapRef<() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>[]> & {} & import("vue").ComponentCustomProperties;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    rootPrefixCls: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    } & {
+        default: string;
+    };
+}>>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[], unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, {
+    rootPrefixCls: string;
+}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("@vue/runtime-core").Plugin;
+export { TConfigProvider };

package/es/config-provider/index.js

@@ -0,0 +1,4 @@
+import { withInstall } from "../utils/type.js";
+import ConfigProvider from "./src/config-provider.js";
+const TConfigProvider = withInstall(ConfigProvider);
+export { TConfigProvider };

package/es/config-provider/src/config-provider.d.ts

@@ -0,0 +1,25 @@
+export declare const configProviderProps: {
+    rootPrefixCls: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    } & {
+        default: string;
+    };
+};
+declare const _default: import("vue").DefineComponent<{
+    rootPrefixCls: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    } & {
+        default: string;
+    };
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[], unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    rootPrefixCls: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    } & {
+        default: string;
+    };
+}>>, {
+    rootPrefixCls: string;
+}>;
+export default _default;