tanxin-ui 0.2.0

package/lib/slider/src/slider.js

@@ -0,0 +1,432 @@
+"use strict";
+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));
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+var vue = require("vue");
+var type = require("../../utils/type.js");
+var useConfig = require("../../utils/hooks/useConfig.js");
+var index = require("../../line-grid/index.js");
+var index$1 = require("../../tooltip/index.js");
+var common = require("../../utils/common.js");
+const sliderProps = {
+  size: type.PropTypes.oneOf(["xs", "sm", "md", "lg", "xl"]).def("md"),
+  value: [Array, Number],
+  step: type.PropTypes.number,
+  vertical: type.PropTypes.bool.def(false),
+  showDot: type.PropTypes.bool.def(false),
+  showInput: type.PropTypes.bool.def(false),
+  showTooltip: type.PropTypes.bool.def(true),
+  tooltipFormat: {
+    type: Function,
+    default: (value) => value
+  },
+  markFormat: {
+    type: Function,
+    default: (value) => value
+  },
+  marks: Array,
+  onlyMark: type.PropTypes.bool.def(false),
+  min: type.PropTypes.number.def(0),
+  max: type.PropTypes.number.def(100),
+  range: type.PropTypes.bool.def(false)
+};
+var Slider = vue.defineComponent({
+  name: "TSlider",
+  components: {
+    TRow: index.TRow,
+    TCol: index.TCol,
+    TTooltip: index$1.TTooltip
+  },
+  inheritAttrs: false,
+  props: sliderProps,
+  emits: ["update:value"],
+  setup(props, {
+    emit
+  }) {
+    const {
+      prefixCls
+    } = useConfig.useConfig("slider", props);
+    const left = props.vertical ? "top" : "left";
+    const width = props.vertical ? "height" : "width";
+    const thumbMouseMoving = vue.ref(false);
+    const refSelected = vue.ref(null);
+    const refBar = vue.ref(null);
+    const refThumb = [vue.ref(), vue.ref()];
+    const activeIndex = vue.ref(-1);
+    const thumbRadius = 6;
+    const refTooltip = [vue.ref(null), vue.ref(null)];
+    const tooltipVisible = [vue.ref(false), vue.ref(false)];
+    const currentValue = vue.ref([props.min, void 0]);
+    const classes = vue.computed(() => {
+      return [[`${prefixCls.value}`], {
+        [`size-${props.size}`]: props.size,
+        [`is-vertical`]: props.vertical
+      }];
+    });
+    const updateValueAndPosition = (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+      if (activeIndex.value < 0)
+        return;
+      if (props.showTooltip)
+        tooltipVisible[activeIndex.value].value = true;
+      const barRect = refBar.value.getBoundingClientRect();
+      let selectedWidth = props.vertical ? event.y - barRect.y : event.x - barRect.x;
+      selectedWidth = Math.max(0, Math.min(barRect[width], selectedWidth));
+      const trackWidth = barRect[width];
+      updateCurrentValue(selectedWidth, trackWidth, activeIndex.value);
+      updateThumbPosition(trackWidth, activeIndex.value);
+      updateSelectedPosition(trackWidth);
+      commitValue();
+    };
+    const updateThumbPosition = (trackWidth, index2) => {
+      const selectedWidth = currentValue.value[index2] / (props.max - props.min) * trackWidth;
+      refThumb[index2].value.style[left] = `${selectedWidth - thumbRadius}px`;
+    };
+    const updateSelectedPosition = (trackWidth) => {
+      if (props.range) {
+        const leftVal = Math.min(currentValue.value[0], currentValue.value[1]) / (props.max - props.min) * trackWidth;
+        let widthVal = (currentValue.value[1] - currentValue.value[0]) / (props.max - props.min) * trackWidth;
+        if (widthVal < 0)
+          widthVal = -widthVal;
+        refSelected.value.style[width] = `${widthVal}px`;
+        refSelected.value.style[left] = `${leftVal}px`;
+      } else {
+        refSelected.value.style[width] = `${(currentValue.value[0] - props.min) / (props.max - props.min) * trackWidth}px`;
+      }
+    };
+    const updateCurrentValue = (selectedWidth, trackWidth, index2) => {
+      let value = Math.round(selectedWidth / trackWidth * (props.max - props.min));
+      if (props.step || props.onlyMark) {
+        const nextValue = dotList.value.find((item) => item.number > value);
+        const preValue = dotList.value.reverse().find((item) => item.number <= value);
+        dotList.value.reverse();
+        if (preValue && nextValue) {
+          const middleValue = (nextValue.number - preValue.number) / 2 + preValue.number;
+          value = value < middleValue ? preValue.number : nextValue.number;
+          currentValue.value[index2] = value;
+          refTooltip[index2].value.updatePosition();
+        }
+      } else {
+        currentValue.value[index2] = value;
+        refTooltip[index2].value.updatePosition();
+      }
+    };
+    const commitValue = () => {
+      if (props.range) {
+        emit("update:value", currentValue.value);
+      } else {
+        emit("update:value", currentValue.value[0]);
+      }
+    };
+    const handleThumbMousemove = (event) => {
+      if (!thumbMouseMoving.value)
+        return;
+      updateValueAndPosition(event);
+    };
+    const handleThumbMouseup = () => {
+      thumbMouseMoving.value = false;
+      if (activeIndex.value < 0)
+        return;
+      tooltipVisible[activeIndex.value].value = false;
+      activeIndex.value = -1;
+      if (!common.isClient)
+        return;
+      document.removeEventListener("mousemove", handleThumbMousemove, true);
+      document.removeEventListener("mouseup", handleThumbMousemove, true);
+      document.removeEventListener("touchmove", handleThumbMousemove, true);
+      document.removeEventListener("touchend", handleThumbMousemove, true);
+      if (props.range) {
+        if (currentValue.value[0] > currentValue.value[1]) {
+          const temp = currentValue.value[0];
+          currentValue.value[0] = currentValue.value[1];
+          currentValue.value[1] = temp;
+        }
+      }
+    };
+    const mousedownActiveIndex = (event) => {
+      if (props.range) {
+        const barRect = refBar.value.getBoundingClientRect();
+        if (currentValue.value[0] !== void 0 && currentValue.value[1] !== void 0) {
+          const middlePos = (Math.abs(currentValue.value[1] - currentValue.value[0]) / 2 + currentValue.value[0]) / (props.max - props.min) * barRect[width];
+          activeIndex.value = event.x - barRect.x < middlePos ? 0 : 1;
+        } else
+          activeIndex.value = 0;
+      } else
+        activeIndex.value = 0;
+    };
+    const handleThumbMousedown = (event) => {
+      if (!refBar.value.contains(event.target))
+        return;
+      thumbMouseMoving.value = true;
+      if (props.range) {
+        if (!refThumb[0].value.contains(event.target) && !refThumb[1].value.contains(event.target))
+          mousedownActiveIndex(event);
+      } else {
+        if (!refThumb[0].value.contains(event.target))
+          mousedownActiveIndex(event);
+      }
+      if (!common.isClient)
+        return;
+      document.addEventListener("mousemove", handleThumbMousemove, true);
+      document.addEventListener("mouseup", handleThumbMouseup, true);
+      document.addEventListener("touchmove", handleThumbMousemove, true);
+      document.addEventListener("touchend", handleThumbMouseup, true);
+      updateValueAndPosition(event);
+    };
+    const barWidth = vue.ref(0);
+    const onResize = () => {
+      if (!refBar.value)
+        return;
+      const barRect = refBar.value.getBoundingClientRect();
+      barWidth.value = barRect[width];
+      stepLength.value = props.step / (props.max - props.min) * barWidth.value;
+      updateSelectedPosition(barWidth.value);
+      updateThumbPosition(barWidth.value, 0);
+      if (props.range)
+        updateThumbPosition(barWidth.value, 1);
+    };
+    vue.onBeforeUnmount(() => {
+      if (!common.isClient)
+        return;
+      document.removeEventListener("mousedown", handleThumbMousedown, true);
+      window.removeEventListener("resize", onResize, true);
+    });
+    vue.onMounted(() => {
+      currentValue.value = props.range ? props.value : [props.value, void 0];
+      initPosition();
+      if (!common.isClient)
+        return;
+      document.addEventListener("mousedown", handleThumbMousedown, true);
+      window.addEventListener("resize", onResize, true);
+    });
+    const setActiveIndex = (index2) => {
+      if (!thumbMouseMoving.value)
+        activeIndex.value = index2;
+    };
+    const tooltipContent = vue.computed(() => {
+      return [{
+        content: () => {
+          return vue.createVNode("span", null, [props.tooltipFormat(currentValue.value[0])]);
+        }
+      }, {
+        content: () => {
+          return vue.createVNode("span", null, [props.tooltipFormat(currentValue.value[1])]);
+        }
+      }];
+    });
+    const onUpdateVisible = (value) => {
+      if (activeIndex.value < 0) {
+        tooltipVisible[0].value = false;
+        tooltipVisible[1].value = false;
+      } else
+        tooltipVisible[activeIndex.value].value = value;
+    };
+    const stepLength = vue.ref(0);
+    const initPosition = () => {
+      const barRect = refBar.value.getBoundingClientRect();
+      barWidth.value = barRect[width];
+      onResize();
+      const trackWidth = barWidth.value;
+      const length = props.max - props.min;
+      let leftVal = currentValue.value[0] / length * trackWidth - thumbRadius;
+      if (leftVal < -thumbRadius)
+        leftVal = -thumbRadius;
+      else if (leftVal >= trackWidth - thumbRadius)
+        leftVal = trackWidth - thumbRadius;
+      refThumb[0].value.style[left] = `${leftVal}px`;
+      if (props.range) {
+        let right = currentValue.value[1] / length * trackWidth - thumbRadius;
+        if (right < -thumbRadius)
+          right = -thumbRadius;
+        else if (right >= trackWidth - thumbRadius)
+          right = trackWidth - thumbRadius;
+        refThumb[1].value.style[left] = `${right}px`;
+      }
+      updateSelectedPosition(trackWidth);
+    };
+    const dotList = vue.computed(() => {
+      let list = [];
+      if (!refBar.value)
+        return list;
+      const trackWidth = barWidth.value;
+      if (props.step) {
+        const count = (props.max - props.min) / props.step;
+        list = Array.from({
+          length: count
+        }).map((item, index2) => {
+          const number = props.min + props.step * index2;
+          return {
+            number,
+            stepStyle: {
+              [left]: `${stepLength.value * index2 - 3}px`
+            },
+            markStyle: {
+              [left]: `${stepLength.value * index2}px`
+            },
+            label: props.markFormat(number),
+            mark: false
+          };
+        });
+        list.push({
+          number: props.max,
+          stepStyle: {
+            [left]: `${stepLength.value * count - 3}px`
+          },
+          markStyle: {
+            [left]: `${stepLength.value * count}px`
+          },
+          label: props.markFormat(props.max),
+          mark: false
+        });
+      }
+      if (props.marks) {
+        props.marks.map((item) => {
+          var _a, _b;
+          const style = (_a = item.style) != null ? _a : {};
+          const widthVal = item.number / (props.max - props.min) * trackWidth;
+          const index2 = list.findIndex((dot) => dot.number == item.number);
+          if (index2 >= 0)
+            list.splice(index2, 1);
+          list.push({
+            number: item.number,
+            stepStyle: __spreadProps(__spreadValues({}, style), {
+              [left]: `${widthVal - 3}px`
+            }),
+            markStyle: __spreadProps(__spreadValues({}, style), {
+              [left]: `${widthVal}px`
+            }),
+            label: (_b = item.label) != null ? _b : props.markFormat(item.number),
+            mark: true
+          });
+        });
+      }
+      const compare = (property) => {
+        return (a, b) => {
+          const value1 = a[property];
+          const value2 = b[property];
+          return value1 - value2;
+        };
+      };
+      return list.sort(compare("number"));
+    });
+    const onUpdateValue = (value, index2) => {
+      const barRect = refBar.value.getBoundingClientRect();
+      currentValue.value[index2] = Math.min(Math.max(props.min, value), props.max);
+      updateSelectedPosition(barRect[width]);
+      commitValue();
+    };
+    vue.watch(() => props.value, () => {
+      currentValue.value = props.range ? props.value : [props.value, void 0];
+      initPosition();
+    }, {
+      deep: true
+    });
+    const render = () => {
+      return vue.createVNode(vue.Fragment, null, [vue.createVNode(vue.resolveComponent("t-row"), {
+        "class": classes.value
+      }, {
+        default: () => [vue.createVNode(vue.resolveComponent("t-col"), {
+          "class": `${prefixCls.value}-outer`,
+          "flex": 1
+        }, {
+          default: () => [vue.createVNode("div", {
+            "ref": refBar,
+            "class": `${prefixCls.value}-bar`
+          }, [vue.createVNode("div", {
+            "ref": refSelected,
+            "class": `${prefixCls.value}-selected`
+          }, null), vue.createVNode(vue.resolveComponent("t-tooltip"), {
+            "disabled": !props.showTooltip,
+            "visible": tooltipVisible[0].value,
+            "onUpdate:visible": onUpdateVisible,
+            "ref": refTooltip[0]
+          }, __spreadValues({
+            default: () => [vue.createVNode("div", {
+              "ref": refThumb[0],
+              "onMouseover": () => setActiveIndex(0),
+              "class": [`${prefixCls.value}-thumb`, {
+                [`is-focus`]: activeIndex.value == 0
+              }],
+              "tabindex": 0
+            }, null)]
+          }, tooltipContent.value[0])), props.range ? vue.createVNode(vue.resolveComponent("t-tooltip"), {
+            "disabled": !props.showTooltip,
+            "visible": tooltipVisible[1].value,
+            "onUpdate:visible": onUpdateVisible,
+            "ref": refTooltip[1]
+          }, __spreadValues({
+            default: () => [vue.createVNode("div", {
+              "ref": refThumb[1],
+              "onMouseover": () => setActiveIndex(1),
+              "class": [`${prefixCls.value}-thumb`, {
+                [`is-focus`]: activeIndex.value == 1
+              }],
+              "tabindex": 0
+            }, null)]
+          }, tooltipContent.value[1])) : null, props.showDot ? dotList.value.map((item) => {
+            return vue.createVNode("span", {
+              "class": [[`${prefixCls.value}-dot`], {
+                [`is-selected`]: props.range ? item.number >= currentValue.value[0] && item.number <= currentValue.value[1] : item.number <= currentValue.value[0]
+              }],
+              "style": item.stepStyle
+            }, null);
+          }) : null]), props.marks ? vue.createVNode("div", {
+            "class": `${prefixCls.value}-marks`
+          }, [dotList.value.map((item) => {
+            return item.mark ? vue.createVNode("span", {
+              "class": `${prefixCls.value}-marks-mark`,
+              "style": item.markStyle
+            }, [item.label]) : null;
+          })]) : null]
+        }), props.showInput ? vue.createVNode(vue.Fragment, null, [vue.createVNode(vue.resolveComponent("t-col"), {
+          "class": `${prefixCls.value}-input`
+        }, {
+          default: () => [vue.createVNode(vue.resolveComponent("t-input-number"), {
+            "placeholder": "",
+            "value": currentValue.value[0],
+            "size": props.size,
+            "onUpdate:value": (value) => onUpdateValue(value, 0),
+            "min": props.min,
+            "max": props.max
+          }, null)]
+        }), props.range ? vue.createVNode(vue.resolveComponent("t-col"), {
+          "class": `${prefixCls.value}-input`
+        }, {
+          default: () => [vue.createVNode(vue.resolveComponent("t-input-number"), {
+            "placeholder": "",
+            "value": currentValue.value[1],
+            "size": props.size,
+            "onUpdate:value": (value) => onUpdateValue(value, 1),
+            "min": props.min,
+            "max": props.max
+          }, null)]
+        }) : null]) : null]
+      })]);
+    };
+    return {
+      render
+    };
+  },
+  render() {
+    return this.render();
+  }
+});
+exports["default"] = Slider;

package/lib/space/index.d.ts

@@ -0,0 +1,219 @@
+declare const TSpace: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            prefixCls: string;
+            size: (string | number) | [string | number, string | number];
+            direction: string;
+            wrap: boolean;
+            justify: string;
+            align: string;
+            percent: number;
+            buttonGroup: boolean;
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            prefixCls: import("vue-types").VueTypeValidableDef<string> & {
+                default: string;
+            };
+            size: {
+                type: import("vue").PropType<(string | number) | [string | number, string | number]>;
+                default: number;
+            };
+            direction: import("vue-types").VueTypeDef<string> & {
+                default: string;
+            };
+            justify: import("vue-types").VueTypeDef<string> & {
+                default: string;
+            };
+            align: import("vue-types").VueTypeDef<string> & {
+                default: string;
+            };
+            wrap: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            } & {
+                default: boolean;
+            };
+            buttonGroup: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            } & {
+                default: boolean;
+            };
+            percent: import("vue-types").VueTypeValidableDef<number> & {
+                default: number;
+            } & {
+                default: number;
+            };
+            itemSize: import("vue").PropType<(string | number) | [string | number, string | number]>;
+            marginTop: import("vue-types").VueTypeDef<string | number>;
+            marginBottom: import("vue-types").VueTypeDef<string | number>;
+            marginLeft: import("vue-types").VueTypeDef<string | number>;
+            marginRight: import("vue-types").VueTypeDef<string | number>;
+        }>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "prefixCls" | "size" | "direction" | "wrap" | "justify" | "align" | "percent" | "buttonGroup">;
+        $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<{
+            prefixCls: import("vue-types").VueTypeValidableDef<string> & {
+                default: string;
+            };
+            size: {
+                type: import("vue").PropType<(string | number) | [string | number, string | number]>;
+                default: number;
+            };
+            direction: import("vue-types").VueTypeDef<string> & {
+                default: string;
+            };
+            justify: import("vue-types").VueTypeDef<string> & {
+                default: string;
+            };
+            align: import("vue-types").VueTypeDef<string> & {
+                default: string;
+            };
+            wrap: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            } & {
+                default: boolean;
+            };
+            buttonGroup: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            } & {
+                default: boolean;
+            };
+            percent: import("vue-types").VueTypeValidableDef<number> & {
+                default: number;
+            } & {
+                default: number;
+            };
+            itemSize: import("vue").PropType<(string | number) | [string | number, string | number]>;
+            marginTop: import("vue-types").VueTypeDef<string | number>;
+            marginBottom: import("vue-types").VueTypeDef<string | number>;
+            marginLeft: import("vue-types").VueTypeDef<string | number>;
+            marginRight: import("vue-types").VueTypeDef<string | number>;
+        }>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, {
+            prefixCls: string;
+            size: (string | number) | [string | number, string | number];
+            direction: string;
+            wrap: boolean;
+            justify: string;
+            align: string;
+            percent: number;
+            buttonGroup: boolean;
+        }> & {
+            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<{
+        prefixCls: import("vue-types").VueTypeValidableDef<string> & {
+            default: string;
+        };
+        size: {
+            type: import("vue").PropType<(string | number) | [string | number, string | number]>;
+            default: number;
+        };
+        direction: import("vue-types").VueTypeDef<string> & {
+            default: string;
+        };
+        justify: import("vue-types").VueTypeDef<string> & {
+            default: string;
+        };
+        align: import("vue-types").VueTypeDef<string> & {
+            default: string;
+        };
+        wrap: import("vue-types").VueTypeValidableDef<boolean> & {
+            default: boolean;
+        } & {
+            default: boolean;
+        };
+        buttonGroup: import("vue-types").VueTypeValidableDef<boolean> & {
+            default: boolean;
+        } & {
+            default: boolean;
+        };
+        percent: import("vue-types").VueTypeValidableDef<number> & {
+            default: number;
+        } & {
+            default: number;
+        };
+        itemSize: import("vue").PropType<(string | number) | [string | number, string | number]>;
+        marginTop: import("vue-types").VueTypeDef<string | number>;
+        marginBottom: import("vue-types").VueTypeDef<string | number>;
+        marginLeft: import("vue-types").VueTypeDef<string | number>;
+        marginRight: import("vue-types").VueTypeDef<string | number>;
+    }>> & import("vue").ShallowUnwrapRef<() => JSX.Element> & {} & import("vue").ComponentCustomProperties;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    prefixCls: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    size: {
+        type: import("vue").PropType<(string | number) | [string | number, string | number]>;
+        default: number;
+    };
+    direction: import("vue-types").VueTypeDef<string> & {
+        default: string;
+    };
+    justify: import("vue-types").VueTypeDef<string> & {
+        default: string;
+    };
+    align: import("vue-types").VueTypeDef<string> & {
+        default: string;
+    };
+    wrap: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    buttonGroup: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    percent: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    } & {
+        default: number;
+    };
+    itemSize: import("vue").PropType<(string | number) | [string | number, string | number]>;
+    marginTop: import("vue-types").VueTypeDef<string | number>;
+    marginBottom: import("vue-types").VueTypeDef<string | number>;
+    marginLeft: import("vue-types").VueTypeDef<string | number>;
+    marginRight: import("vue-types").VueTypeDef<string | number>;
+}>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, {
+    prefixCls: string;
+    size: (string | number) | [string | number, string | number];
+    direction: string;
+    wrap: boolean;
+    justify: string;
+    align: string;
+    percent: number;
+    buttonGroup: boolean;
+}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("@vue/runtime-core").Plugin;
+export { TSpace };

package/lib/space/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+var type = require("../utils/type.js");
+var space = require("./src/space.js");
+const TSpace = type.withInstall(space["default"]);
+exports.TSpace = TSpace;