@talex-touch/tuffex 0.3.3

package/dist/lib/tooltip/src/TxTooltip.vue2.js

@@ -0,0 +1,442 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+const vue$1 = require('@floating-ui/vue');
+
+const _hoisted_1 = ["data-side"];
+const _hoisted_2 = {
+  class: "tx-tooltip__fusion-filters",
+  width: "0",
+  height: "0",
+  "aria-hidden": "true"
+};
+const _hoisted_3 = ["values"];
+const _hoisted_4 = ["data-side"];
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{ name: "TxTooltip" },
+  __name: "TxTooltip",
+  props: {
+    modelValue: { type: Boolean, default: void 0 },
+    content: { default: "" },
+    disabled: { type: Boolean, default: false },
+    trigger: { default: "hover" },
+    placement: { default: "top" },
+    offset: { default: 8 },
+    openDelay: { default: 200 },
+    closeDelay: { default: 120 },
+    maxWidth: { default: 280 },
+    showArrow: { type: Boolean, default: false },
+    arrowSize: { default: 12 },
+    interactive: { type: Boolean, default: false },
+    closeOnClickOutside: { type: Boolean, default: true },
+    motion: { default: "split" },
+    fusion: { type: Boolean, default: false },
+    panelVariant: { default: "solid" },
+    panelBackground: { default: "blur" },
+    panelShadow: { default: "soft" },
+    panelRadius: { default: 10 },
+    panelPadding: { default: 8 }
+  },
+  emits: ["update:modelValue", "open", "close"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const internalOpen = vue.ref(false);
+    const open = vue.computed({
+      get: () => typeof props.modelValue === "boolean" ? props.modelValue : internalOpen.value,
+      set: (v) => {
+        if (props.disabled)
+          return;
+        internalOpen.value = v;
+        emit("update:modelValue", v);
+        if (v)
+          emit("open");
+        else
+          emit("close");
+      }
+    });
+    const referenceRef = vue.ref(null);
+    const floatingRef = vue.ref(null);
+    const arrowRef = vue.ref(null);
+    const cleanupAutoUpdate = vue.ref(null);
+    const lastOpenedAt = vue.ref(0);
+    const stablePlacement = vue.ref(null);
+    const { floatingStyles, middlewareData, placement, update } = vue$1.useFloating(referenceRef, floatingRef, {
+      placement: vue.computed(() => props.placement),
+      strategy: "fixed",
+      transform: false,
+      middleware: [
+        vue$1.offset(() => props.offset),
+        vue$1.flip({ padding: 8 }),
+        vue$1.shift({ padding: 8 }),
+        vue$1.size({
+          padding: 8,
+          apply({ elements }) {
+            Object.assign(elements.floating.style, {
+              maxWidth: `${props.maxWidth}px`
+            });
+          }
+        }),
+        vue$1.arrow({
+          element: vue.computed(() => arrowRef.value),
+          padding: 6
+        })
+      ]
+    });
+    const splitX = vue.ref(0);
+    const splitY = vue.ref(0);
+    const motion = vue.computed(() => props.motion === "fade" ? "fade" : "split");
+    const tooltipClass = vue.computed(() => {
+      return [
+        "tx-tooltip",
+        `is-variant-${props.panelVariant}`,
+        `is-bg-${props.panelBackground}`,
+        `is-shadow-${props.panelShadow}`,
+        { "is-fusion": !!props.fusion, "is-motion-split": motion.value === "split" }
+      ];
+    });
+    const tooltipVars = vue.computed(() => {
+      const side = String(stablePlacement.value || placement.value || props.placement || "top").split("-")[0];
+      const arrowData = middlewareData.value?.arrow;
+      const arrowSize = props.arrowSize || 12;
+      let fusionX = "50%";
+      let fusionY = "50%";
+      if (props.showArrow && arrowData) {
+        if (side === "top" || side === "bottom") {
+          if (arrowData.x != null)
+            fusionX = `${arrowData.x + arrowSize * 0.5}px`;
+        } else {
+          if (arrowData.y != null)
+            fusionY = `${arrowData.y + arrowSize * 0.5}px`;
+        }
+      }
+      return {
+        "--tx-tooltip-radius": `${props.panelRadius}px`,
+        "--tx-tooltip-padding": `${props.panelPadding}px`,
+        "--tx-tooltip-arrow-size": `${props.arrowSize}px`,
+        "--tx-tooltip-split-x": `${splitX.value}px`,
+        "--tx-tooltip-split-y": `${splitY.value}px`,
+        "--tx-tooltip-fusion-x": fusionX,
+        "--tx-tooltip-fusion-y": fusionY
+      };
+    });
+    const uid = vue.useId();
+    const gooFilterId = `tx-tooltip-goo-${uid}`;
+    const gooMatrixValues = vue.computed(() => {
+      const alpha = 26;
+      const alphaOffset = -12;
+      return `1 0 0 0 0  0 1 0 0 0  0 0 1 0 0  0 0 0 ${alpha} ${alphaOffset}`;
+    });
+    const fusionVars = vue.computed(() => {
+      const out = Math.max(12, (props.offset ?? 8) + (props.arrowSize ?? 12) * 0.8);
+      const size2 = Math.max(26, (props.arrowSize ?? 12) * 3.2);
+      return {
+        "--tx-tooltip-goo-out": `${out}px`,
+        "--tx-tooltip-goo-size": `${size2}px`
+      };
+    });
+    let openTimer = null;
+    let closeTimer = null;
+    function clearTimers() {
+      if (openTimer)
+        window.clearTimeout(openTimer);
+      if (closeTimer)
+        window.clearTimeout(closeTimer);
+      openTimer = null;
+      closeTimer = null;
+    }
+    function scheduleOpen() {
+      if (props.disabled)
+        return;
+      clearTimers();
+      openTimer = window.setTimeout(async () => {
+        lastOpenedAt.value = performance.now();
+        open.value = true;
+        await vue.nextTick();
+        await update();
+      }, props.openDelay);
+    }
+    function scheduleClose() {
+      clearTimers();
+      closeTimer = window.setTimeout(() => {
+        open.value = false;
+      }, props.closeDelay);
+    }
+    function onEnter() {
+      if (props.trigger !== "hover")
+        return;
+      scheduleOpen();
+    }
+    function onLeave() {
+      if (props.trigger !== "hover")
+        return;
+      scheduleClose();
+    }
+    function onFloatingEnter() {
+      if (!props.interactive)
+        return;
+      if (props.trigger !== "hover")
+        return;
+      clearTimers();
+    }
+    function onFloatingLeave() {
+      if (!props.interactive)
+        return;
+      if (props.trigger !== "hover")
+        return;
+      scheduleClose();
+    }
+    function onFocusIn() {
+      if (props.trigger !== "focus")
+        return;
+      scheduleOpen();
+    }
+    function onFocusOut() {
+      if (props.trigger !== "focus")
+        return;
+      scheduleClose();
+    }
+    function onClickToggle() {
+      if (props.trigger !== "click")
+        return;
+      clearTimers();
+      if (!open.value)
+        lastOpenedAt.value = performance.now();
+      open.value = !open.value;
+    }
+    function isEventInside(e, el) {
+      if (!el)
+        return false;
+      const anyE = e;
+      const path = typeof anyE.composedPath === "function" ? anyE.composedPath() : void 0;
+      if (path && path.length)
+        return path.includes(el);
+      const t = e.target ?? null;
+      return !!t && el.contains(t);
+    }
+    function handleOutside(e) {
+      if (!props.closeOnClickOutside)
+        return;
+      if (props.trigger !== "click")
+        return;
+      if (!open.value)
+        return;
+      if (performance.now() - lastOpenedAt.value < 60)
+        return;
+      const inRef = isEventInside(e, referenceRef.value);
+      const inFloat = isEventInside(e, floatingRef.value);
+      if (!inRef && !inFloat)
+        open.value = false;
+    }
+    function onEsc(e) {
+      if (e.key !== "Escape")
+        return;
+      if (!open.value)
+        return;
+      open.value = false;
+    }
+    vue.watch(
+      open,
+      async (v) => {
+        if (!v) {
+          stablePlacement.value = null;
+          cleanupAutoUpdate.value?.();
+          cleanupAutoUpdate.value = null;
+          return;
+        }
+        await vue.nextTick();
+        await update();
+        stablePlacement.value = placement.value;
+        if (referenceRef.value && floatingRef.value) {
+          cleanupAutoUpdate.value?.();
+          cleanupAutoUpdate.value = vue$1.autoUpdate(referenceRef.value, floatingRef.value, () => update());
+        }
+      },
+      { flush: "post" }
+    );
+    vue.onMounted(async () => {
+      document.addEventListener("pointerdown", handleOutside, true);
+      document.addEventListener("keydown", onEsc);
+      await vue.nextTick();
+      if (referenceRef.value) {
+        await update();
+      }
+    });
+    vue.onBeforeUnmount(() => {
+      document.removeEventListener("pointerdown", handleOutside, true);
+      document.removeEventListener("keydown", onEsc);
+      clearTimers();
+      cleanupAutoUpdate.value?.();
+      cleanupAutoUpdate.value = null;
+    });
+    const arrowStyle = vue.computed(() => {
+      if (!props.showArrow || !arrowRef.value)
+        return { display: "none" };
+      const data = middlewareData.value?.arrow;
+      if (!data || data.x == null && data.y == null) {
+        return { display: "none" };
+      }
+      const x = data.x;
+      const y = data.y;
+      const side = String(placement.value || props.placement || "top").split("-")[0];
+      const base = {
+        display: "block",
+        position: "absolute"
+      };
+      if (x != null)
+        base.left = `${x}px`;
+      if (y != null)
+        base.top = `${y}px`;
+      let staticSide = "bottom";
+      switch (side) {
+        case "top":
+          staticSide = "bottom";
+          break;
+        case "right":
+          staticSide = "left";
+          break;
+        case "bottom":
+          staticSide = "top";
+          break;
+        case "left":
+          staticSide = "right";
+          break;
+      }
+      const half = Math.round((props.arrowSize || 12) / 2);
+      base[staticSide] = `calc(-${half}px + 1px)`;
+      return base;
+    });
+    const arrowSide = vue.computed(() => String(stablePlacement.value || placement.value || props.placement || "top").split("-")[0]);
+    function onBeforeEnter(el) {
+      if (motion.value !== "split") {
+        splitX.value = 0;
+        splitY.value = 0;
+        return;
+      }
+      const node = el;
+      const refEl = referenceRef.value;
+      if (!refEl)
+        return;
+      const refRect = refEl.getBoundingClientRect();
+      const side = arrowSide.value;
+      const refCx = refRect.left + refRect.width * 0.5;
+      const refCy = refRect.top + refRect.height * 0.5;
+      let tipX = refCx;
+      let tipY = refCy;
+      const arrowEl = props.showArrow ? arrowRef.value : null;
+      if (arrowEl) {
+        const arrowRect = arrowEl.getBoundingClientRect();
+        tipX = arrowRect.left + arrowRect.width * 0.5;
+        tipY = arrowRect.top + arrowRect.height * 0.5;
+        if (side === "top")
+          tipY = arrowRect.bottom;
+        if (side === "bottom")
+          tipY = arrowRect.top;
+        if (side === "left")
+          tipX = arrowRect.right;
+        if (side === "right")
+          tipX = arrowRect.left;
+      } else {
+        const floatRect = node.getBoundingClientRect();
+        tipX = floatRect.left + floatRect.width * 0.5;
+        tipY = floatRect.top + floatRect.height * 0.5;
+      }
+      const dx = refCx - tipX;
+      const dy = refCy - tipY;
+      const limit = 18;
+      const clamp = (v) => Math.min(limit, Math.max(-limit, v));
+      splitX.value = side === "left" || side === "right" ? clamp(dx) : 0;
+      splitY.value = side === "top" || side === "bottom" ? clamp(dy) : 0;
+    }
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock(vue.Fragment, null, [
+        vue.createElementVNode("span", {
+          ref_key: "referenceRef",
+          ref: referenceRef,
+          class: "tx-tooltip__reference",
+          onMouseenter: onEnter,
+          onMouseleave: onLeave,
+          onFocusin: onFocusIn,
+          onFocusout: onFocusOut,
+          onClickCapture: onClickToggle
+        }, [
+          vue.renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ], 544),
+        (vue.openBlock(), vue.createBlock(vue.Teleport, { to: "body" }, [
+          vue.createVNode(vue.Transition, {
+            name: "tx-tooltip",
+            onBeforeEnter
+          }, {
+            default: vue.withCtx(() => [
+              open.value && !__props.disabled ? (vue.openBlock(), vue.createElementBlock("div", {
+                key: 0,
+                ref_key: "floatingRef",
+                ref: floatingRef,
+                class: vue.normalizeClass(tooltipClass.value),
+                "data-side": arrowSide.value,
+                role: "tooltip",
+                style: vue.normalizeStyle([vue.unref(floatingStyles), tooltipVars.value]),
+                onMouseenter: onFloatingEnter,
+                onMouseleave: onFloatingLeave
+              }, [
+                (vue.openBlock(), vue.createElementBlock("svg", _hoisted_2, [
+                  vue.createElementVNode("defs", null, [
+                    vue.createElementVNode("filter", { id: gooFilterId }, [
+                      _cache[0] || (_cache[0] = vue.createElementVNode("feGaussianBlur", {
+                        in: "SourceGraphic",
+                        stdDeviation: "12",
+                        result: "blur"
+                      }, null, -1)),
+                      vue.createElementVNode("feColorMatrix", {
+                        in: "blur",
+                        mode: "matrix",
+                        values: gooMatrixValues.value,
+                        result: "goo"
+                      }, null, 8, _hoisted_3),
+                      _cache[1] || (_cache[1] = vue.createElementVNode("feComposite", {
+                        in: "SourceGraphic",
+                        in2: "goo",
+                        operator: "atop"
+                      }, null, -1))
+                    ])
+                  ])
+                ])),
+                props.showArrow ? (vue.openBlock(), vue.createElementBlock("div", {
+                  key: 0,
+                  ref_key: "arrowRef",
+                  ref: arrowRef,
+                  class: "tx-tooltip__arrow",
+                  "data-side": arrowSide.value,
+                  style: vue.normalizeStyle(arrowStyle.value),
+                  "aria-hidden": "true"
+                }, null, 12, _hoisted_4)) : vue.createCommentVNode("", true),
+                props.fusion && motion.value === "split" ? (vue.openBlock(), vue.createElementBlock("div", {
+                  key: 1,
+                  class: "tx-tooltip__fusion",
+                  style: vue.normalizeStyle(fusionVars.value),
+                  "aria-hidden": "true"
+                }, [
+                  vue.createElementVNode("div", {
+                    class: "tx-tooltip__fusion-goo",
+                    style: vue.normalizeStyle({ filter: `url(#${gooFilterId})` })
+                  }, [..._cache[2] || (_cache[2] = [
+                    vue.createElementVNode("div", { class: "tx-tooltip__fusion-blob tx-tooltip__fusion-blob--tip" }, null, -1),
+                    vue.createElementVNode("div", { class: "tx-tooltip__fusion-blob tx-tooltip__fusion-blob--ref" }, null, -1)
+                  ])], 4)
+                ], 4)) : vue.createCommentVNode("", true),
+                vue.renderSlot(_ctx.$slots, "content", {}, () => [
+                  vue.createTextVNode(vue.toDisplayString(__props.content), 1)
+                ], true)
+              ], 46, _hoisted_1)) : vue.createCommentVNode("", true)
+            ]),
+            _: 3
+          })
+        ]))
+      ], 64);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/dist/lib/transition/index.js

@@ -0,0 +1,30 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const withInstall = require('../utils/withInstall.js');
+const TxTransition_vue_vue_type_script_setup_true_lang = require('./src/TxTransition.vue.js');
+;/* empty css                       */
+const TxTransitionFade_vue_vue_type_script_setup_true_lang = require('./src/TxTransitionFade.vue.js');
+const TxTransitionRebound_vue_vue_type_script_setup_true_lang = require('./src/TxTransitionRebound.vue.js');
+const TxTransitionSlideFade_vue_vue_type_script_setup_true_lang = require('./src/TxTransitionSlideFade.vue.js');
+const TxTransitionSmoothSize_vue_vue_type_script_setup_true_lang = require('./src/TxTransitionSmoothSize.vue.js');
+;/* empty css                                 */
+
+const Transition = withInstall.withInstall(TxTransition_vue_vue_type_script_setup_true_lang.default);
+const TransitionFade = withInstall.withInstall(TxTransitionFade_vue_vue_type_script_setup_true_lang.default);
+const TransitionSlideFade = withInstall.withInstall(TxTransitionSlideFade_vue_vue_type_script_setup_true_lang.default);
+const TransitionRebound = withInstall.withInstall(TxTransitionRebound_vue_vue_type_script_setup_true_lang.default);
+const TransitionSmoothSize = withInstall.withInstall(TxTransitionSmoothSize_vue_vue_type_script_setup_true_lang.default);
+
+exports.TxTransition = TxTransition_vue_vue_type_script_setup_true_lang.default;
+exports.TxTransitionFade = TxTransitionFade_vue_vue_type_script_setup_true_lang.default;
+exports.TxTransitionRebound = TxTransitionRebound_vue_vue_type_script_setup_true_lang.default;
+exports.TxTransitionSlideFade = TxTransitionSlideFade_vue_vue_type_script_setup_true_lang.default;
+exports.TxTransitionSmoothSize = TxTransitionSmoothSize_vue_vue_type_script_setup_true_lang.default;
+exports.Transition = Transition;
+exports.TransitionFade = TransitionFade;
+exports.TransitionRebound = TransitionRebound;
+exports.TransitionSlideFade = TransitionSlideFade;
+exports.TransitionSmoothSize = TransitionSmoothSize;
+exports.default = Transition;

package/dist/lib/transition/src/TxTransition.vue.js

@@ -0,0 +1,94 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+const TxTransitionSmoothSize_vue_vue_type_script_setup_true_lang = require('./TxTransitionSmoothSize.vue.js');
+;/* empty css                             */
+
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{
+    name: "TxTransition",
+    inheritAttrs: false
+  },
+  __name: "TxTransition",
+  props: {
+    preset: { default: "fade" },
+    group: { type: Boolean, default: false },
+    tag: { default: "div" },
+    appear: { type: Boolean, default: true },
+    mode: { default: "out-in" },
+    duration: { default: 180 },
+    easing: { default: "cubic-bezier(0.2, 0, 0, 1)" }
+  },
+  setup(__props) {
+    const props = __props;
+    const attrs = vue.useAttrs();
+    const name = vue.computed(() => {
+      if (props.preset === "slide-fade")
+        return "tx-slide-fade";
+      if (props.preset === "rebound")
+        return "tx-rebound";
+      if (props.preset === "smooth-size")
+        return "tx-smooth-size";
+      return "tx-fade";
+    });
+    const styleVars = vue.computed(() => {
+      return {
+        "--tx-transition-duration": `${props.duration}ms`,
+        "--tx-transition-easing": props.easing
+      };
+    });
+    const passThroughAttrs = vue.computed(() => {
+      const { class: _c, style: _s, ...rest } = attrs;
+      return rest;
+    });
+    const wrapperClass = vue.computed(() => {
+      return ["tx-transition", attrs.class];
+    });
+    const wrapperStyle = vue.computed(() => {
+      return [styleVars.value, attrs.style];
+    });
+    return (_ctx, _cache) => {
+      return __props.preset === "smooth-size" && !__props.group ? (vue.openBlock(), vue.createBlock(TxTransitionSmoothSize_vue_vue_type_script_setup_true_lang.default, vue.mergeProps({ key: 0 }, passThroughAttrs.value, {
+        duration: __props.duration,
+        easing: __props.easing,
+        appear: __props.appear,
+        mode: __props.mode
+      }), {
+        default: vue.withCtx(() => [
+          vue.renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      }, 16, ["duration", "easing", "appear", "mode"])) : (vue.openBlock(), vue.createElementBlock("div", {
+        key: 1,
+        class: vue.normalizeClass(wrapperClass.value),
+        style: vue.normalizeStyle(wrapperStyle.value)
+      }, [
+        __props.group ? (vue.openBlock(), vue.createBlock(vue.TransitionGroup, vue.mergeProps({
+          key: 0,
+          name: name.value,
+          tag: __props.tag,
+          appear: __props.appear
+        }, passThroughAttrs.value), {
+          default: vue.withCtx(() => [
+            vue.renderSlot(_ctx.$slots, "default")
+          ]),
+          _: 3
+        }, 16, ["name", "tag", "appear"])) : (vue.openBlock(), vue.createBlock(vue.Transition, vue.mergeProps({
+          key: 1,
+          name: name.value,
+          appear: __props.appear,
+          mode: __props.mode
+        }, passThroughAttrs.value), {
+          default: vue.withCtx(() => [
+            vue.renderSlot(_ctx.$slots, "default")
+          ]),
+          _: 3
+        }, 16, ["name", "appear", "mode"]))
+      ], 6));
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/dist/lib/transition/src/TxTransition.vue3.js

@@ -0,0 +1,10 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const TxTransition_vue_vue_type_script_setup_true_lang = require('./TxTransition.vue.js');
+;/* empty css                   */
+
+
+
+exports.default = TxTransition_vue_vue_type_script_setup_true_lang.default;

package/dist/lib/transition/src/TxTransitionFade.vue.js

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+const TxTransition_vue_vue_type_script_setup_true_lang = require('./TxTransition.vue.js');
+;/* empty css                   */
+
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{ name: "TxTransitionFade", inheritAttrs: false },
+  __name: "TxTransitionFade",
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(TxTransition_vue_vue_type_script_setup_true_lang.default, vue.mergeProps({ preset: "fade" }, _ctx.$attrs), {
+        default: vue.withCtx(() => [
+          vue.renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      }, 16);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/dist/lib/transition/src/TxTransitionFade.vue2.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const TxTransitionFade_vue_vue_type_script_setup_true_lang = require('./TxTransitionFade.vue.js');
+
+
+
+exports.default = TxTransitionFade_vue_vue_type_script_setup_true_lang.default;

package/dist/lib/transition/src/TxTransitionRebound.vue.js

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+const TxTransition_vue_vue_type_script_setup_true_lang = require('./TxTransition.vue.js');
+;/* empty css                   */
+
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{ name: "TxTransitionRebound", inheritAttrs: false },
+  __name: "TxTransitionRebound",
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(TxTransition_vue_vue_type_script_setup_true_lang.default, vue.mergeProps({ preset: "rebound" }, _ctx.$attrs), {
+        default: vue.withCtx(() => [
+          vue.renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      }, 16);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/dist/lib/transition/src/TxTransitionRebound.vue2.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const TxTransitionRebound_vue_vue_type_script_setup_true_lang = require('./TxTransitionRebound.vue.js');
+
+
+
+exports.default = TxTransitionRebound_vue_vue_type_script_setup_true_lang.default;

package/dist/lib/transition/src/TxTransitionSlideFade.vue.js

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+const TxTransition_vue_vue_type_script_setup_true_lang = require('./TxTransition.vue.js');
+;/* empty css                   */
+
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{ name: "TxTransitionSlideFade", inheritAttrs: false },
+  __name: "TxTransitionSlideFade",
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(TxTransition_vue_vue_type_script_setup_true_lang.default, vue.mergeProps({ preset: "slide-fade" }, _ctx.$attrs), {
+        default: vue.withCtx(() => [
+          vue.renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      }, 16);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/dist/lib/transition/src/TxTransitionSlideFade.vue2.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const TxTransitionSlideFade_vue_vue_type_script_setup_true_lang = require('./TxTransitionSlideFade.vue.js');
+
+
+
+exports.default = TxTransitionSlideFade_vue_vue_type_script_setup_true_lang.default;