@talex-touch/tuffex 0.3.3

package/dist/lib/glow-text/src/TxGlowText.vue2.js

@@ -0,0 +1,58 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+
+const _hoisted_1 = { class: "tx-glow-text__content" };
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{ name: "TxGlowText" },
+  __name: "TxGlowText",
+  props: {
+    tag: { default: "span" },
+    active: { type: Boolean, default: true },
+    durationMs: { default: 1400 },
+    delayMs: { default: 0 },
+    angle: { default: 20 },
+    bandSize: { default: 38 },
+    color: { default: "rgba(255, 255, 255, 0.9)" },
+    opacity: { default: 0.75 },
+    blendMode: { default: "screen" },
+    radius: { default: 10 },
+    repeat: { type: Boolean, default: true }
+  },
+  setup(__props) {
+    const props = __props;
+    const styleVars = vue.computed(() => {
+      return {
+        "--tx-glow-duration": `${props.durationMs}ms`,
+        "--tx-glow-delay": `${props.delayMs}ms`,
+        "--tx-glow-angle": `${props.angle}deg`,
+        "--tx-glow-band": `${props.bandSize}%`,
+        "--tx-glow-color": props.color,
+        "--tx-glow-opacity": String(props.opacity),
+        "--tx-glow-radius": `${props.radius}px`,
+        "--tx-glow-blend-mode": props.blendMode
+      };
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(__props.tag), {
+        class: vue.normalizeClass(["tx-glow-text", { "is-inactive": !__props.active, "is-once": !__props.repeat }]),
+        style: vue.normalizeStyle(styleVars.value)
+      }, {
+        default: vue.withCtx(() => [
+          vue.createElementVNode("span", _hoisted_1, [
+            vue.renderSlot(_ctx.$slots, "default", {}, void 0, true)
+          ]),
+          _cache[0] || (_cache[0] = vue.createElementVNode("span", {
+            class: "tx-glow-text__shine",
+            "aria-hidden": "true"
+          }, null, -1))
+        ]),
+        _: 3
+      }, 8, ["class", "style"]);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/dist/lib/gradient-border/index.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const withInstall = require('../utils/withInstall.js');
+const TxGradientBorder = require('./src/TxGradientBorder.vue.js');
+
+const GradientBorder = withInstall.withInstall(TxGradientBorder.default);
+
+exports.TxGradientBorder = TxGradientBorder.default;
+exports.GradientBorder = GradientBorder;
+exports.default = GradientBorder;

package/dist/lib/gradient-border/src/TxGradientBorder.vue.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const TxGradientBorder_vue_vue_type_script_setup_true_lang = require('./TxGradientBorder.vue2.js');
+;/* empty css                       */
+const _pluginVue_exportHelper = require('../../_virtual/_plugin-vue_export-helper.js');
+
+const TxGradientBorder = /* @__PURE__ */ _pluginVue_exportHelper.default(TxGradientBorder_vue_vue_type_script_setup_true_lang.default, [["__scopeId", "data-v-4beb4427"]]);
+
+exports.default = TxGradientBorder;

package/dist/lib/gradient-border/src/TxGradientBorder.vue2.js

@@ -0,0 +1,49 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+
+const _hoisted_1 = { class: "tx-gradient-border__inner" };
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{
+    name: "TxGradientBorder"
+  },
+  __name: "TxGradientBorder",
+  props: {
+    as: { default: "div" },
+    borderWidth: { default: "2px" },
+    borderRadius: { default: "12px" },
+    padding: { default: "12px" },
+    animationDuration: { default: 4 }
+  },
+  setup(__props) {
+    const props = __props;
+    function toCssUnit(value) {
+      return typeof value === "number" ? `${value}px` : value;
+    }
+    const rootStyle = vue.computed(() => {
+      return {
+        "--tx-gradient-border-width": toCssUnit(props.borderWidth),
+        "--tx-gradient-border-radius": toCssUnit(props.borderRadius),
+        "--tx-gradient-inner-padding": toCssUnit(props.padding),
+        "--tx-gradient-duration": `${props.animationDuration}s`
+      };
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(__props.as), {
+        class: "tx-gradient-border",
+        style: vue.normalizeStyle(rootStyle.value)
+      }, {
+        default: vue.withCtx(() => [
+          vue.createElementVNode("span", _hoisted_1, [
+            vue.renderSlot(_ctx.$slots, "default", {}, void 0, true)
+          ])
+        ]),
+        _: 3
+      }, 8, ["style"]);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/dist/lib/gradual-blur/index.js

@@ -0,0 +1,13 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const withInstall = require('../utils/withInstall.js');
+const TxGradualBlur_vue_vue_type_script_setup_true_lang = require('./src/TxGradualBlur.vue.js');
+;/* empty css                        */
+
+const GradualBlur = withInstall.withInstall(TxGradualBlur_vue_vue_type_script_setup_true_lang.default);
+
+exports.TxGradualBlur = TxGradualBlur_vue_vue_type_script_setup_true_lang.default;
+exports.GradualBlur = GradualBlur;
+exports.default = GradualBlur;

package/dist/lib/gradual-blur/src/TxGradualBlur.vue.js

@@ -0,0 +1,297 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+const env = require('../../utils/env.js');
+
+const _hoisted_1 = { class: "tx-gradual-blur__inner" };
+const _hoisted_2 = {
+  key: 0,
+  class: "tx-gradual-blur__slot"
+};
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{
+    name: "TxGradualBlur"
+  },
+  __name: "TxGradualBlur",
+  props: {
+    position: { default: "bottom" },
+    strength: { default: 2 },
+    height: { default: "6rem" },
+    width: { default: void 0 },
+    divCount: { default: 5 },
+    exponential: { type: Boolean, default: false },
+    zIndex: { default: 1e3 },
+    animated: { type: [Boolean, String], default: false },
+    duration: { default: "0.3s" },
+    easing: { default: "ease-out" },
+    opacity: { default: 1 },
+    curve: { default: "linear" },
+    responsive: { type: Boolean, default: false },
+    mobileHeight: {},
+    tabletHeight: {},
+    desktopHeight: {},
+    mobileWidth: {},
+    tabletWidth: {},
+    desktopWidth: {},
+    preset: {},
+    gpuOptimized: { type: Boolean },
+    hoverIntensity: {},
+    target: { default: "parent" },
+    onAnimationComplete: {},
+    className: { default: "" },
+    style: { default: () => ({}) }
+  },
+  setup(__props) {
+    const props = __props;
+    const DEFAULT_CONFIG = {
+      position: "bottom",
+      strength: 2,
+      height: "6rem",
+      divCount: 5,
+      exponential: false,
+      zIndex: 1e3,
+      animated: false,
+      duration: "0.3s",
+      easing: "ease-out",
+      opacity: 1,
+      curve: "linear",
+      responsive: false,
+      target: "parent",
+      className: "",
+      style: {}
+    };
+    const PRESETS = {
+      "top": { position: "top", height: "6rem" },
+      "bottom": { position: "bottom", height: "6rem" },
+      "left": { position: "left", height: "6rem" },
+      "right": { position: "right", height: "6rem" },
+      "subtle": { height: "4rem", strength: 1, opacity: 0.8, divCount: 3 },
+      "intense": { height: "10rem", strength: 4, divCount: 8, exponential: true },
+      "smooth": { height: "8rem", curve: "bezier", divCount: 10 },
+      "sharp": { height: "5rem", curve: "linear", divCount: 4 },
+      "header": { position: "top", height: "8rem", curve: "ease-out" },
+      "footer": { position: "bottom", height: "8rem", curve: "ease-out" },
+      "sidebar": { position: "left", height: "6rem", strength: 2.5 },
+      "page-header": {
+        position: "top",
+        height: "10rem",
+        target: "page",
+        strength: 3
+      },
+      "page-footer": {
+        position: "bottom",
+        height: "10rem",
+        target: "page",
+        strength: 3
+      }
+    };
+    const CURVE_FUNCTIONS = {
+      "linear": (p) => p,
+      "bezier": (p) => p * p * (3 - 2 * p),
+      "ease-in": (p) => p * p,
+      "ease-out": (p) => 1 - (1 - p) ** 2,
+      "ease-in-out": (p) => p < 0.5 ? 2 * p * p : 1 - (-2 * p + 2) ** 2 / 2
+    };
+    const containerRef = vue.ref(null);
+    const isHovered = vue.ref(false);
+    const isVisible = vue.ref(true);
+    const responsiveHeight = vue.ref(props.height);
+    const responsiveWidth = vue.ref(props.width);
+    const config = vue.computed(() => {
+      const presetConfig = props.preset ? PRESETS[props.preset] || {} : {};
+      return {
+        ...DEFAULT_CONFIG,
+        ...presetConfig,
+        ...props
+      };
+    });
+    function getGradientDirection(position) {
+      const directions = {
+        top: "to top",
+        bottom: "to bottom",
+        left: "to left",
+        right: "to right"
+      };
+      return directions[position || "bottom"] || "to bottom";
+    }
+    function debounce(fn, wait) {
+      let timeout;
+      return (...args) => {
+        if (timeout)
+          clearTimeout(timeout);
+        timeout = setTimeout(() => fn(...args), wait);
+      };
+    }
+    function updateResponsiveDimensions() {
+      if (!config.value.responsive)
+        return;
+      if (!env.hasWindow())
+        return;
+      const width = window.innerWidth;
+      const currentConfig = config.value;
+      let newHeight = currentConfig.height;
+      if (width <= 480 && currentConfig.mobileHeight) {
+        newHeight = currentConfig.mobileHeight;
+      } else if (width <= 768 && currentConfig.tabletHeight) {
+        newHeight = currentConfig.tabletHeight;
+      } else if (width <= 1024 && currentConfig.desktopHeight) {
+        newHeight = currentConfig.desktopHeight;
+      }
+      responsiveHeight.value = newHeight;
+      let newWidth = currentConfig.width;
+      if (width <= 480 && currentConfig.mobileWidth) {
+        newWidth = currentConfig.mobileWidth;
+      } else if (width <= 768 && currentConfig.tabletWidth) {
+        newWidth = currentConfig.tabletWidth;
+      } else if (width <= 1024 && currentConfig.desktopWidth) {
+        newWidth = currentConfig.desktopWidth;
+      }
+      responsiveWidth.value = newWidth;
+    }
+    let intersectionObserver = null;
+    function setupIntersectionObserver() {
+      if (config.value.animated !== "scroll")
+        return;
+      if (!containerRef.value)
+        return;
+      if (typeof IntersectionObserver === "undefined")
+        return;
+      intersectionObserver = new IntersectionObserver(
+        (entries) => {
+          const entry = entries[0];
+          if (!entry)
+            return;
+          isVisible.value = entry.isIntersecting;
+        },
+        { threshold: 0.1 }
+      );
+      intersectionObserver.observe(containerRef.value);
+    }
+    const blurDivs = vue.computed(() => {
+      const divs = [];
+      const count = Math.max(1, Math.floor(config.value.divCount));
+      const increment = 100 / count;
+      const currentStrength = isHovered.value && config.value.hoverIntensity ? config.value.strength * config.value.hoverIntensity : config.value.strength;
+      const curveFunc = CURVE_FUNCTIONS[config.value.curve] || CURVE_FUNCTIONS.linear;
+      for (let i = 1; i <= count; i++) {
+        let progress = i / count;
+        progress = curveFunc(progress);
+        const blurValue = config.value.exponential ? 2 ** (progress * 4) * 0.0625 * currentStrength : 0.0625 * (progress * count + 1) * currentStrength;
+        const p1 = Math.round((increment * i - increment) * 10) / 10;
+        const p2 = Math.round(increment * i * 10) / 10;
+        const p3 = Math.round((increment * i + increment) * 10) / 10;
+        const p4 = Math.round((increment * i + increment * 2) * 10) / 10;
+        let gradient = `transparent ${p1}%, black ${p2}%`;
+        if (p3 <= 100)
+          gradient += `, black ${p3}%`;
+        if (p4 <= 100)
+          gradient += `, transparent ${p4}%`;
+        const direction = getGradientDirection(config.value.position);
+        const divStyle = {
+          maskImage: `linear-gradient(${direction}, ${gradient})`,
+          WebkitMaskImage: `linear-gradient(${direction}, ${gradient})`,
+          backdropFilter: `blur(${blurValue.toFixed(3)}rem)`,
+          WebkitBackdropFilter: `blur(${blurValue.toFixed(3)}rem)`,
+          opacity: config.value.opacity,
+          transition: config.value.animated && config.value.animated !== "scroll" ? `backdrop-filter ${config.value.duration} ${config.value.easing}` : void 0
+        };
+        divs.push({ style: divStyle });
+      }
+      return divs;
+    });
+    const containerStyle = vue.computed(() => {
+      const isVertical = ["top", "bottom"].includes(config.value.position);
+      const isHorizontal = ["left", "right"].includes(config.value.position);
+      const isPageTarget = config.value.target === "page";
+      const baseStyle = {
+        position: isPageTarget ? "fixed" : "absolute",
+        pointerEvents: config.value.hoverIntensity ? "auto" : "none",
+        opacity: isVisible.value ? 1 : 0,
+        transition: config.value.animated ? `opacity ${config.value.duration} ${config.value.easing}` : void 0,
+        zIndex: isPageTarget ? config.value.zIndex + 100 : config.value.zIndex,
+        willChange: config.value.gpuOptimized ? "backdrop-filter, opacity" : void 0,
+        transform: config.value.gpuOptimized ? "translateZ(0)" : void 0,
+        ...config.value.style
+      };
+      if (isVertical) {
+        baseStyle.height = responsiveHeight.value;
+        baseStyle.width = responsiveWidth.value || "100%";
+        baseStyle[config.value.position] = "0";
+        baseStyle.left = "0";
+        baseStyle.right = "0";
+      } else if (isHorizontal) {
+        baseStyle.width = responsiveWidth.value || responsiveHeight.value;
+        baseStyle.height = "100%";
+        baseStyle[config.value.position] = "0";
+        baseStyle.top = "0";
+        baseStyle.bottom = "0";
+      }
+      return baseStyle;
+    });
+    const debouncedResize = debounce(updateResponsiveDimensions, 100);
+    vue.onMounted(() => {
+      if (config.value.responsive) {
+        updateResponsiveDimensions();
+        window.addEventListener("resize", debouncedResize);
+      }
+      if (config.value.animated === "scroll") {
+        isVisible.value = false;
+        setupIntersectionObserver();
+      }
+    });
+    vue.onUnmounted(() => {
+      if (config.value.responsive) {
+        window.removeEventListener("resize", debouncedResize);
+      }
+      if (intersectionObserver) {
+        intersectionObserver.disconnect();
+        intersectionObserver = null;
+      }
+    });
+    vue.watch(
+      () => isVisible.value,
+      (newVisible) => {
+        if (!newVisible)
+          return;
+        if (config.value.animated !== "scroll")
+          return;
+        if (!props.onAnimationComplete)
+          return;
+        const timeout = setTimeout(() => {
+          props.onAnimationComplete?.();
+        }, Number.parseFloat(config.value.duration) * 1e3);
+        return () => clearTimeout(timeout);
+      }
+    );
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        ref_key: "containerRef",
+        ref: containerRef,
+        class: vue.normalizeClass(["tx-gradual-blur", [
+          config.value.target === "page" ? "tx-gradual-blur--page" : "tx-gradual-blur--parent",
+          config.value.className
+        ]]),
+        style: vue.normalizeStyle(containerStyle.value),
+        onMouseenter: _cache[0] || (_cache[0] = ($event) => config.value.hoverIntensity ? isHovered.value = true : void 0),
+        onMouseleave: _cache[1] || (_cache[1] = ($event) => config.value.hoverIntensity ? isHovered.value = false : void 0)
+      }, [
+        vue.createElementVNode("div", _hoisted_1, [
+          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(blurDivs.value, (div, index) => {
+            return vue.openBlock(), vue.createElementBlock("div", {
+              key: index,
+              class: "tx-gradual-blur__layer",
+              style: vue.normalizeStyle(div.style)
+            }, null, 4);
+          }), 128))
+        ]),
+        _ctx.$slots.default ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_2, [
+          vue.renderSlot(_ctx.$slots, "default")
+        ])) : vue.createCommentVNode("", true)
+      ], 38);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/dist/lib/gradual-blur/src/TxGradualBlur.vue3.js

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

package/dist/lib/grid/index.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const TxGrid = require('./src/TxGrid.vue.js');
+const TxGridItem = require('./src/TxGridItem.vue.js');
+
+TxGrid.default.install = (app) => {
+  app.component(TxGrid.default.name || "TxGrid", TxGrid.default);
+};
+TxGridItem.default.install = (app) => {
+  app.component(TxGridItem.default.name || "TxGridItem", TxGridItem.default);
+};
+
+exports.Grid = TxGrid.default;
+exports.TxGrid = TxGrid.default;
+exports.default = TxGrid.default;
+exports.GridItem = TxGridItem.default;
+exports.TxGridItem = TxGridItem.default;

package/dist/lib/grid/src/TxGrid.vue.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const TxGrid_vue_vue_type_script_setup_true_lang = require('./TxGrid.vue2.js');
+;/* empty css             */
+const _pluginVue_exportHelper = require('../../_virtual/_plugin-vue_export-helper.js');
+
+const TxGrid = /* @__PURE__ */ _pluginVue_exportHelper.default(TxGrid_vue_vue_type_script_setup_true_lang.default, [["__scopeId", "data-v-2a48ba7d"]]);
+
+exports.default = TxGrid;

package/dist/lib/grid/src/TxGrid.vue2.js

@@ -0,0 +1,125 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+const env = require('../../utils/env.js');
+
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{ name: "TxGrid" },
+  __name: "TxGrid",
+  props: {
+    cols: { default: 0 },
+    rows: { default: 0 },
+    gap: { default: 16 },
+    minItemWidth: { default: "" },
+    justify: { default: "stretch" },
+    align: { default: "stretch" }
+  },
+  setup(__props) {
+    const props = __props;
+    const width = vue.ref(env.hasWindow() ? window.innerWidth : 1024);
+    function getBp(w) {
+      if (w < 640)
+        return "xs";
+      if (w < 768)
+        return "sm";
+      if (w < 1024)
+        return "md";
+      if (w < 1280)
+        return "lg";
+      return "xl";
+    }
+    function onResize() {
+      if (!env.hasWindow())
+        return;
+      width.value = window.innerWidth;
+    }
+    vue.onMounted(() => {
+      if (env.hasWindow()) {
+        window.addEventListener("resize", onResize, { passive: true });
+      }
+    });
+    vue.onBeforeUnmount(() => {
+      if (env.hasWindow()) {
+        window.removeEventListener("resize", onResize);
+      }
+    });
+    function toCssSize(v) {
+      if (v == null)
+        return "";
+      if (typeof v === "number")
+        return `${v}px`;
+      return String(v);
+    }
+    function resolveResponsive(v) {
+      const bp = getBp(width.value);
+      return v[bp] ?? v.md ?? v.sm ?? v.xs ?? v.lg ?? v.xl;
+    }
+    const resolvedCols = vue.computed(() => {
+      if (typeof props.cols === "number")
+        return props.cols;
+      if (props.cols && typeof props.cols === "object") {
+        const n = resolveResponsive(props.cols);
+        return Number.isFinite(n) ? Number(n) : 0;
+      }
+      return 0;
+    });
+    const resolvedGap = vue.computed(() => {
+      const gap = props.gap;
+      if (gap == null)
+        return { row: "16px", col: "16px" };
+      if (typeof gap === "number" || typeof gap === "string") {
+        const s2 = toCssSize(gap);
+        return { row: s2, col: s2 };
+      }
+      if (typeof gap === "object") {
+        const hasRowCol = "row" in gap || "col" in gap;
+        if (hasRowCol) {
+          return {
+            row: toCssSize(gap.row ?? 16),
+            col: toCssSize(gap.col ?? 16)
+          };
+        }
+        const v = resolveResponsive(gap);
+        const s2 = toCssSize(v ?? 16);
+        return { row: s2, col: s2 };
+      }
+      const s = toCssSize(gap);
+      return { row: s, col: s };
+    });
+    const style = vue.computed(() => {
+      const rowGap = resolvedGap.value.row;
+      const colGap = resolvedGap.value.col;
+      let templateCols = "";
+      if (props.minItemWidth) {
+        templateCols = `repeat(auto-fit, minmax(${props.minItemWidth}, 1fr))`;
+      } else if ((resolvedCols.value ?? 0) > 0) {
+        templateCols = `repeat(${resolvedCols.value}, minmax(0, 1fr))`;
+      }
+      let templateRows = "";
+      if ((props.rows ?? 0) > 0) {
+        templateRows = `repeat(${props.rows}, minmax(0, 1fr))`;
+      }
+      return {
+        display: "grid",
+        gridTemplateColumns: templateCols,
+        gridTemplateRows: templateRows,
+        rowGap,
+        columnGap: colGap,
+        justifyItems: props.justify || "stretch",
+        alignItems: props.align || "stretch"
+      };
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: "tx-grid",
+        style: vue.normalizeStyle(style.value)
+      }, [
+        vue.renderSlot(_ctx.$slots, "default", {}, void 0, true)
+      ], 4);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/dist/lib/grid/src/TxGridItem.vue.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const TxGridItem_vue_vue_type_script_setup_true_lang = require('./TxGridItem.vue2.js');
+;/* empty css                 */
+const _pluginVue_exportHelper = require('../../_virtual/_plugin-vue_export-helper.js');
+
+const TxGridItem = /* @__PURE__ */ _pluginVue_exportHelper.default(TxGridItem_vue_vue_type_script_setup_true_lang.default, [["__scopeId", "data-v-67080dd2"]]);
+
+exports.default = TxGridItem;

package/dist/lib/grid/src/TxGridItem.vue2.js

@@ -0,0 +1,40 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{ name: "TxGridItem" },
+  __name: "TxGridItem",
+  props: {
+    colSpan: { default: 1 },
+    rowSpan: { default: 1 },
+    justifySelf: { default: "" },
+    alignSelf: { default: "" }
+  },
+  setup(__props) {
+    const props = __props;
+    const style = vue.computed(() => {
+      const out = {
+        gridColumn: `span ${Math.max(1, props.colSpan ?? 1)} / span ${Math.max(1, props.colSpan ?? 1)}`,
+        gridRow: `span ${Math.max(1, props.rowSpan ?? 1)} / span ${Math.max(1, props.rowSpan ?? 1)}`
+      };
+      if (props.justifySelf)
+        out.justifySelf = props.justifySelf;
+      if (props.alignSelf)
+        out.alignSelf = props.alignSelf;
+      return out;
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: "tx-grid-item",
+        style: vue.normalizeStyle(style.value)
+      }, [
+        vue.renderSlot(_ctx.$slots, "default", {}, void 0, true)
+      ], 4);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/dist/lib/grid-layout/index.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const withInstall = require('../utils/withInstall.js');
+const TxGridLayout = require('./src/TxGridLayout.vue.js');
+
+const GridLayout = withInstall.withInstall(TxGridLayout.default);
+
+exports.TxGridLayout = TxGridLayout.default;
+exports.GridLayout = GridLayout;
+exports.default = GridLayout;