tanxin-ui 0.2.0

package/es/select/src/select.js

@@ -0,0 +1,449 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import { defineComponent, ref, computed, watch, createVNode, mergeProps, withDirectives, resolveDirective, Fragment, resolveComponent } from "vue";
+import { PropTypes, isArray } from "../../utils/type.js";
+import { TPopper } from "../../popper/index.js";
+import SelectTrigger from "./select-trigger.js";
+import SelectContent from "./select-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 "../../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 { provideSelect } from "./context.js";
+import { useConfig } from "../../utils/hooks/useConfig.js";
+import { directive } from "../../utils/directives/click-outside.js";
+const selectProps = {
+  size: PropTypes.oneOf(["xs", "sm", "md", "lg", "xl"]).def("md"),
+  readonly: PropTypes.bool.def(false),
+  disabled: PropTypes.bool.def(false),
+  loading: PropTypes.bool.def(false),
+  visible: PropTypes.bool.def(false),
+  multiple: PropTypes.bool.def(false),
+  sameWidth: PropTypes.bool.def(true),
+  maxTags: PropTypes.number,
+  moreText: PropTypes.func,
+  showSearch: PropTypes.bool.def(false),
+  searchPlaceholder: PropTypes.string,
+  popperClass: PropTypes.string.def("is-select"),
+  emptyText: PropTypes.string,
+  selectedList: {
+    type: Array,
+    default: () => []
+  },
+  maxWidth: [String, Number],
+  triggerWidth: PropTypes.oneOf(["parent", "content"]).def("parent"),
+  filterMethod: {
+    type: Function,
+    default: (keyword, option) => {
+      if (option.label)
+        return option.label.indexOf(keyword) >= 0;
+      if (isArray(option.children))
+        return option.children[0].children.indexOf(keyword) >= 0;
+      return false;
+    }
+  },
+  remoteMethod: {
+    type: Function
+  },
+  options: {
+    type: Array,
+    default: () => []
+  },
+  placeholder: PropTypes.string,
+  value: {
+    type: [Array, String, Number]
+  },
+  clearable: PropTypes.bool.def(true),
+  prefix: PropTypes.string,
+  suffix: PropTypes.string,
+  showPath: PropTypes.bool.def(false),
+  addible: PropTypes.bool.def(false)
+};
+var Select = defineComponent({
+  name: "TSelect",
+  components: {
+    TPopper,
+    CloseCircleOutline,
+    ChevronDown
+  },
+  directives: {
+    clickOutside: directive
+  },
+  inheritAttrs: false,
+  props: selectProps,
+  emits: ["update:value", "update:visible"],
+  setup(props, {
+    slots,
+    emit,
+    attrs
+  }) {
+    const currentValue = ref(isArray(props.value) ? props.value : props.value ? [props.value] : []);
+    const optionDataList = ref([]);
+    const selectedList = ref(props.selectedList);
+    const {
+      prefixCls
+    } = useConfig("select", props);
+    const refContent = ref();
+    const focusArr = [ref(), ref()];
+    const setOptionDataList = (list) => {
+      optionDataList.value = list;
+    };
+    const appendOptionDataList = (list) => {
+      optionDataList.value.push(...list);
+    };
+    const updateValue = (item) => {
+      if (props.multiple) {
+        const index = currentValue.value ? currentValue.value.indexOf(item.value) : -1;
+        if (index >= 0) {
+          currentValue.value.splice(index, 1);
+          removeSelectedOption(item);
+        } else {
+          currentValue.value.push(item.value);
+          addSelectedOption(item);
+        }
+      } else {
+        currentValue.value[0] = item.value;
+        selectedList.value.length = 0;
+        addSelectedOption(item);
+      }
+      commitValue();
+    };
+    const optionClick = (item) => {
+      if (props.readonly || props.disabled)
+        return;
+      if (!props.multiple) {
+        visible.value = false;
+        refInput.value.focus();
+      } else if (!props.showSearch) {
+        refInput.value.focus();
+      }
+      isFocus.value = true;
+      updateValue(item);
+    };
+    const removeSelectedOption = (item) => {
+      const index = selectedList.value.findIndex((selectedOption) => item.value == selectedOption.value);
+      if (index >= 0)
+        selectedList.value.splice(index, 1);
+    };
+    const addSelectedOption = (item) => {
+      if (selectedList.value.some((selectedOption) => item.value == selectedOption.value))
+        return;
+      selectedList.value.push(item);
+    };
+    const clear = () => {
+      currentValue.value = [];
+      selectedList.value.length = 0;
+      commitValue();
+      visible.value = false;
+      refInput.value.focus();
+    };
+    const show = (bVisible) => {
+      visible.value = bVisible;
+      if (!bVisible)
+        refInput.value.focus();
+    };
+    const getCurrentValue = () => {
+      return props.multiple ? currentValue.value : currentValue.value.length > 0 ? currentValue.value[0] : void 0;
+    };
+    const dispatchChange = () => {
+      if (attrs.hasOwnProperty("onChange")) {
+        const changeEvent = attrs["onChange"];
+        if (isArray(changeEvent))
+          changeEvent.map((event) => event(getCurrentValue()));
+        else
+          changeEvent(getCurrentValue());
+      }
+    };
+    const commitValue = () => {
+      emit("update:value", getCurrentValue());
+      dispatchChange();
+    };
+    const sendSearchInputFocus = (focus) => {
+      focusArr[1].value = focus;
+    };
+    provideSelect({
+      visible: computed(() => visible.value),
+      value: computed(() => currentValue.value),
+      multiple: computed(() => props.multiple),
+      optionDataList: computed(() => optionDataList.value),
+      selectedList: computed(() => selectedList.value),
+      optionClick,
+      addSelectedOption,
+      setOptionDataList,
+      clear,
+      show,
+      sendSearchInputFocus
+    });
+    const visible = ref(props.visible);
+    const refInput = ref();
+    const isFocus = ref(false);
+    const refPopper = ref(null);
+    const refTrigger = ref(null);
+    const handleClickOutside = (event) => {
+      if (refTrigger.value.$el.contains(event.target))
+        return;
+      isFocus.value = false;
+    };
+    const handleClick = () => {
+      isFocus.value = true;
+    };
+    const handleValueChange = () => {
+      if (props.multiple) {
+        for (let i = selectedList.value.length - 1; i >= 0; i--) {
+          if (!currentValue.value.includes(selectedList.value[i].value))
+            selectedList.value.splice(i, 1);
+        }
+        currentValue.value.map((value) => {
+          const found = selectedList.value.find((option) => option.value == value);
+          if (!found) {
+            const newItem = optionDataList.value.find((item) => {
+              return item.value == value;
+            });
+            if (newItem)
+              selectedList.value.push(newItem);
+          }
+        });
+      } else {
+        const arr = optionDataList.value.filter((item) => {
+          return currentValue.value.includes(item.value);
+        });
+        selectedList.value = arr;
+      }
+    };
+    watch(() => props.value, () => {
+      currentValue.value = isArray(props.value) ? props.value : props.value !== null && props.value !== void 0 ? [props.value] : [];
+      handleValueChange();
+    }, {
+      deep: true
+    });
+    watch(() => props.visible, () => {
+      visible.value = props.visible;
+    });
+    watch(() => visible.value, () => {
+      emit("update:visible", visible.value);
+    });
+    watch(() => props.selectedList, () => {
+      selectedList.value = props.selectedList;
+    }, {
+      deep: true
+    });
+    const handleKeydown = (event) => {
+      if (props.showSearch) {
+        switch (event.code) {
+          case "Escape":
+            event.preventDefault();
+            show(false);
+            break;
+          case "Enter":
+            event.preventDefault();
+            if (visible.value)
+              refContent.value.confirmOption();
+            else
+              show(true);
+            break;
+          case "Tab":
+            if (visible.value) {
+              event.preventDefault();
+              show(false);
+            }
+            break;
+        }
+        return;
+      }
+      switch (event.code) {
+        case "Escape":
+          event.preventDefault();
+          show(false);
+          break;
+        case "ArrowDown":
+          event.preventDefault();
+          refContent.value.handleArrowDown();
+          break;
+        case "ArrowUp":
+          event.preventDefault();
+          refContent.value.handleArrowUp();
+          break;
+        case "Enter":
+          event.preventDefault();
+          if (visible.value)
+            refContent.value.confirmOption();
+          else
+            show(true);
+          break;
+        case "Tab":
+          if (visible.value) {
+            event.preventDefault();
+            show(false);
+          }
+          break;
+      }
+    };
+    const emptyClick = (event) => {
+      event.stopPropagation();
+    };
+    const onUpdateVisible = (value) => {
+      visible.value = value;
+    };
+    const render = () => {
+      var _a, _b, _c;
+      const contentProps = __spreadProps(__spreadValues({}, attrs), {
+        size: props.size,
+        readonly: props.readonly,
+        elements: (_a = slots.default) == null ? void 0 : _a.call(slots),
+        options: props.options,
+        showSearch: props.showSearch,
+        filterMethod: props.filterMethod,
+        remoteMethod: props.remoteMethod,
+        searchPlaceholder: props.searchPlaceholder,
+        addible: props.addible
+      });
+      const contentElement = slots.content ? slots.content() : createVNode(SelectContent, mergeProps({
+        "ref": refContent
+      }, contentProps), null);
+      const selectionProps = {
+        size: props.size,
+        readonly: props.readonly,
+        disabled: props.disabled,
+        loading: props.loading,
+        multiple: props.multiple,
+        maxTags: props.maxTags,
+        moreText: props.moreText,
+        placeholder: props.placeholder,
+        clearable: props.clearable,
+        showPath: props.showPath,
+        visible: visible.value,
+        value: currentValue.value,
+        isFocus: isFocus.value,
+        prefix: ((_b = slots.prefix) == null ? void 0 : _b.call(slots)) || props.prefix,
+        suffix: ((_c = slots.suffix) == null ? void 0 : _c.call(slots)) || props.suffix,
+        ref: refTrigger
+      };
+      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;
+        },
+        onKeydown: handleKeydown,
+        onClick: emptyClick
+      };
+      const selectionElement = createVNode("label", attrs, [withDirectives(createVNode("div", {
+        "class": `${prefixCls.value}-selection-outer`
+      }, [createVNode(SelectTrigger, selectionProps, null), createVNode("input", mergeProps({
+        "ref": refInput
+      }, inputProps, {
+        "inputmode": "none"
+      }), null)]), [[resolveDirective("clickOutside"), handleClickOutside]])]);
+      const inSlots = {
+        trigger: () => selectionElement,
+        content: () => contentElement
+      };
+      const popperProps = {
+        placement: "bottomLeft",
+        trigger: "click",
+        transitionName: "slide-up",
+        sameWidth: props.sameWidth,
+        isToggle: true,
+        disabled: props.disabled,
+        offset: 6,
+        showArrow: false,
+        maxWidth: props.maxWidth,
+        triggerWidth: props.triggerWidth
+      };
+      if (!props.disabled)
+        popperProps[`onClick`] = handleClick;
+      return createVNode(Fragment, null, [createVNode(resolveComponent("t-popper"), mergeProps({
+        "ref": refPopper,
+        "class": props.popperClass,
+        "visible": visible.value,
+        "onUpdate:visible": [($event) => visible.value = $event, onUpdateVisible]
+      }, popperProps), inSlots)]);
+    };
+    return {
+      refInput,
+      render,
+      setOptionDataList,
+      initSelected: handleValueChange,
+      appendOptionDataList
+    };
+  },
+  render() {
+    return this.render();
+  }
+});
+export { Select as default };

package/es/skeleton/index.d.ts

@@ -0,0 +1,175 @@
+declare const TSkeleton: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            animated: boolean;
+            rows: number;
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            animated: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            };
+            rows: import("vue-types").VueTypeValidableDef<number> & {
+                default: number;
+            } & {
+                default: number;
+            };
+        }>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "animated" | "rows">;
+        $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<{
+            animated: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            };
+            rows: import("vue-types").VueTypeValidableDef<number> & {
+                default: number;
+            } & {
+                default: number;
+            };
+        }>>, {
+            render: () => JSX.Element;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, {
+            animated: boolean;
+            rows: number;
+        }> & {
+            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<{
+        animated: import("vue-types").VueTypeValidableDef<boolean> & {
+            default: boolean;
+        };
+        rows: import("vue-types").VueTypeValidableDef<number> & {
+            default: number;
+        } & {
+            default: number;
+        };
+    }>> & import("vue").ShallowUnwrapRef<{
+        render: () => JSX.Element;
+    }> & {} & import("vue").ComponentCustomProperties;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    animated: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    };
+    rows: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    } & {
+        default: number;
+    };
+}>>, {
+    render: () => JSX.Element;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, {
+    animated: boolean;
+    rows: number;
+}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("@vue/runtime-core").Plugin;
+export { TSkeleton };
+declare const TSkeletonItem: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            type: string;
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            type: import("vue-types").VueTypeDef<string> & {
+                default: string;
+            };
+            width: import("vue-types").VueTypeDef<string | number>;
+            height: import("vue-types").VueTypeDef<string | number>;
+        }>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "type">;
+        $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<{
+            type: import("vue-types").VueTypeDef<string> & {
+                default: string;
+            };
+            width: import("vue-types").VueTypeDef<string | number>;
+            height: import("vue-types").VueTypeDef<string | number>;
+        }>>, {
+            render: () => JSX.Element;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, {
+            type: 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<{
+        type: import("vue-types").VueTypeDef<string> & {
+            default: string;
+        };
+        width: import("vue-types").VueTypeDef<string | number>;
+        height: import("vue-types").VueTypeDef<string | number>;
+    }>> & import("vue").ShallowUnwrapRef<{
+        render: () => JSX.Element;
+    }> & {} & import("vue").ComponentCustomProperties;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    type: import("vue-types").VueTypeDef<string> & {
+        default: string;
+    };
+    width: import("vue-types").VueTypeDef<string | number>;
+    height: import("vue-types").VueTypeDef<string | number>;
+}>>, {
+    render: () => JSX.Element;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, {
+    type: string;
+}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("@vue/runtime-core").Plugin;
+export { TSkeletonItem };

package/es/skeleton/index.js

@@ -0,0 +1,6 @@
+import { withInstall } from "../utils/type.js";
+import Skeleton from "./src/skeleton.js";
+import SkeletonItem from "./src/skeleton-item.js";
+const TSkeleton = withInstall(Skeleton);
+const TSkeletonItem = withInstall(SkeletonItem);
+export { TSkeleton, TSkeletonItem };

package/es/skeleton/src/skeleton-item.d.ts

@@ -0,0 +1,18 @@
+declare const _default: import("vue").DefineComponent<{
+    type: import("vue-types").VueTypeDef<string> & {
+        default: string;
+    };
+    width: import("vue-types").VueTypeDef<string | number>;
+    height: import("vue-types").VueTypeDef<string | number>;
+}, {
+    render: () => JSX.Element;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    type: import("vue-types").VueTypeDef<string> & {
+        default: string;
+    };
+    width: import("vue-types").VueTypeDef<string | number>;
+    height: import("vue-types").VueTypeDef<string | number>;
+}>>, {
+    type: string;
+}>;
+export default _default;