@talex-touch/tuffex 0.3.3

package/dist/lib/data-table/src/TxDataTable.vue2.js

@@ -0,0 +1,294 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+require('../../checkbox/index.js');
+const index = require('../../empty-state/index.js');
+require('../../spinner/index.js');
+const TxSpinner_vue_vue_type_script_setup_true_lang = require('../../spinner/src/TxSpinner.vue.js');
+;/* empty css                                */
+const TxCheckbox = require('../../checkbox/src/TxCheckbox.vue.js');
+
+const _hoisted_1 = {
+  key: 0,
+  class: "tx-data-table__loading",
+  "aria-live": "polite"
+};
+const _hoisted_2 = ["aria-busy"];
+const _hoisted_3 = {
+  key: 0,
+  class: "tx-data-table__th tx-data-table__th--select"
+};
+const _hoisted_4 = ["onClick"];
+const _hoisted_5 = {
+  key: 0,
+  class: "tx-data-table__sort",
+  "aria-hidden": "true"
+};
+const _hoisted_6 = ["onClick"];
+const _hoisted_7 = {
+  key: 0,
+  class: "tx-data-table__cell tx-data-table__cell--select"
+};
+const _hoisted_8 = { key: 0 };
+const _hoisted_9 = ["colspan"];
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{ name: "TxDataTable" },
+  __name: "TxDataTable",
+  props: {
+    columns: { default: () => [] },
+    data: { default: () => [] },
+    rowKey: {},
+    loading: { type: Boolean, default: false },
+    emptyText: { default: "No data" },
+    striped: { type: Boolean, default: false },
+    bordered: { type: Boolean, default: false },
+    hover: { type: Boolean, default: true },
+    selectable: { type: Boolean, default: false },
+    selectedKeys: { default: () => [] },
+    defaultSort: {},
+    sortOnClient: { type: Boolean, default: true }
+  },
+  emits: ["update:selectedKeys", "selectionChange", "sortChange", "rowClick"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const localSort = vue.ref(props.defaultSort ?? null);
+    vue.watch(
+      () => props.defaultSort,
+      (next) => {
+        if (!next) {
+          localSort.value = null;
+          return;
+        }
+        localSort.value = next;
+      }
+    );
+    const selectedSet = vue.computed(() => new Set(props.selectedKeys ?? []));
+    function getRowKey(row, index) {
+      if (typeof props.rowKey === "function")
+        return props.rowKey(row, index);
+      if (typeof props.rowKey === "string" && props.rowKey)
+        return row?.[props.rowKey] ?? index;
+      return index;
+    }
+    const rowKeys = vue.computed(() => props.data.map((row, index) => getRowKey(row, index)));
+    const allSelected = vue.computed(() => {
+      if (!rowKeys.value.length)
+        return false;
+      return rowKeys.value.every((key) => selectedSet.value.has(key));
+    });
+    const sortState = vue.computed(() => localSort.value);
+    function normalizeSortOrder(order) {
+      if (order === "asc" || order === "desc")
+        return order;
+      return null;
+    }
+    function setSort(next) {
+      localSort.value = next;
+      emit("sortChange", next);
+    }
+    function toggleSort(column) {
+      if (!column.sortable)
+        return;
+      const current = sortState.value;
+      if (!current || current.key !== column.key) {
+        setSort({ key: column.key, order: "asc" });
+        return;
+      }
+      const order = normalizeSortOrder(current.order);
+      if (order === "asc")
+        setSort({ key: column.key, order: "desc" });
+      else if (order === "desc")
+        setSort(null);
+      else
+        setSort({ key: column.key, order: "asc" });
+    }
+    function getCellValue(row, column) {
+      const key = column.dataIndex ?? column.key;
+      return row?.[key];
+    }
+    function defaultSorter(a, b) {
+      if (a == null && b == null)
+        return 0;
+      if (a == null)
+        return -1;
+      if (b == null)
+        return 1;
+      if (typeof a === "number" && typeof b === "number")
+        return a - b;
+      const sa = String(a);
+      const sb = String(b);
+      return sa.localeCompare(sb);
+    }
+    const displayRows = vue.computed(() => {
+      const rows = props.data.slice();
+      if (!props.sortOnClient)
+        return rows;
+      const state = sortState.value;
+      if (!state)
+        return rows;
+      const col = props.columns.find((c) => c.key === state.key);
+      if (!col)
+        return rows;
+      const dir = state.order === "desc" ? -1 : 1;
+      const sorter = col.sorter ?? ((a, b) => defaultSorter(getCellValue(a, col), getCellValue(b, col)));
+      return rows.sort((a, b) => dir * sorter(a, b));
+    });
+    function toggleRow(key) {
+      const next = new Set(selectedSet.value);
+      if (next.has(key))
+        next.delete(key);
+      else
+        next.add(key);
+      const updated = Array.from(next);
+      emit("update:selectedKeys", updated);
+      emit("selectionChange", updated);
+    }
+    function toggleAll() {
+      const next = allSelected.value ? [] : rowKeys.value;
+      emit("update:selectedKeys", next);
+      emit("selectionChange", next);
+    }
+    function formatCell(row, column, index) {
+      const value = getCellValue(row, column);
+      if (column.format)
+        return column.format(value, row, index);
+      if (value == null)
+        return "";
+      return String(value);
+    }
+    function columnStyle(column) {
+      const style = {};
+      if (column.width !== void 0) {
+        style.width = typeof column.width === "number" ? `${column.width}px` : column.width;
+      }
+      if (column.align)
+        style.textAlign = column.align;
+      return style;
+    }
+    const colspan = vue.computed(() => props.columns.length + (props.selectable ? 1 : 0));
+    function emitRowClick(row, index) {
+      emit("rowClick", { row, index });
+    }
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: vue.normalizeClass(["tx-data-table", {
+          "is-striped": __props.striped,
+          "is-bordered": __props.bordered,
+          "is-hover": __props.hover
+        }])
+      }, [
+        __props.loading ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
+          vue.createVNode(vue.unref(TxSpinner_vue_vue_type_script_setup_true_lang.default), { size: 20 })
+        ])) : vue.createCommentVNode("", true),
+        vue.createElementVNode("table", {
+          class: "tx-data-table__table",
+          "aria-busy": __props.loading
+        }, [
+          vue.createElementVNode("thead", null, [
+            vue.createElementVNode("tr", null, [
+              __props.selectable ? (vue.openBlock(), vue.createElementBlock("th", _hoisted_3, [
+                vue.createVNode(vue.unref(TxCheckbox.default), {
+                  "model-value": allSelected.value,
+                  "aria-label": "Select all",
+                  "onUpdate:modelValue": toggleAll
+                }, null, 8, ["model-value"])
+              ])) : vue.createCommentVNode("", true),
+              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(__props.columns, (column) => {
+                return vue.openBlock(), vue.createElementBlock("th", {
+                  key: column.key,
+                  class: vue.normalizeClass(["tx-data-table__th", [
+                    column.headerClass,
+                    { "is-sortable": column.sortable, "is-sorted": sortState.value?.key === column.key }
+                  ]]),
+                  style: vue.normalizeStyle(columnStyle(column)),
+                  onClick: ($event) => toggleSort(column)
+                }, [
+                  vue.renderSlot(_ctx.$slots, `header-${column.key}`, { column }, () => [
+                    vue.createTextVNode(vue.toDisplayString(column.title), 1)
+                  ], true),
+                  column.sortable ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_5, [
+                    (vue.openBlock(), vue.createElementBlock("svg", {
+                      viewBox: "0 0 24 24",
+                      width: "10",
+                      height: "10",
+                      class: vue.normalizeClass({ "is-active": sortState.value?.key === column.key && sortState.value?.order === "asc" })
+                    }, [..._cache[0] || (_cache[0] = [
+                      vue.createElementVNode("path", {
+                        fill: "currentColor",
+                        d: "M7 14l5-5 5 5z"
+                      }, null, -1)
+                    ])], 2)),
+                    (vue.openBlock(), vue.createElementBlock("svg", {
+                      viewBox: "0 0 24 24",
+                      width: "10",
+                      height: "10",
+                      class: vue.normalizeClass({ "is-active": sortState.value?.key === column.key && sortState.value?.order === "desc" })
+                    }, [..._cache[1] || (_cache[1] = [
+                      vue.createElementVNode("path", {
+                        fill: "currentColor",
+                        d: "M7 10l5 5 5-5z"
+                      }, null, -1)
+                    ])], 2))
+                  ])) : vue.createCommentVNode("", true)
+                ], 14, _hoisted_4);
+              }), 128))
+            ])
+          ]),
+          vue.createElementVNode("tbody", null, [
+            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(displayRows.value, (row, index) => {
+              return vue.openBlock(), vue.createElementBlock("tr", {
+                key: getRowKey(row, index),
+                class: "tx-data-table__row",
+                onClick: ($event) => emitRowClick(row, index)
+              }, [
+                __props.selectable ? (vue.openBlock(), vue.createElementBlock("td", _hoisted_7, [
+                  vue.createVNode(vue.unref(TxCheckbox.default), {
+                    "model-value": selectedSet.value.has(getRowKey(row, index)),
+                    "aria-label": "Select row",
+                    "onUpdate:modelValue": () => toggleRow(getRowKey(row, index))
+                  }, null, 8, ["model-value", "onUpdate:modelValue"])
+                ])) : vue.createCommentVNode("", true),
+                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(__props.columns, (column) => {
+                  return vue.openBlock(), vue.createElementBlock("td", {
+                    key: column.key,
+                    class: vue.normalizeClass(["tx-data-table__cell", column.cellClass]),
+                    style: vue.normalizeStyle(columnStyle(column))
+                  }, [
+                    vue.renderSlot(_ctx.$slots, `cell-${column.key}`, {
+                      row,
+                      column,
+                      value: getCellValue(row, column),
+                      index
+                    }, () => [
+                      vue.createTextVNode(vue.toDisplayString(formatCell(row, column, index)), 1)
+                    ], true)
+                  ], 6);
+                }), 128))
+              ], 8, _hoisted_6);
+            }), 128)),
+            !displayRows.value.length && !__props.loading ? (vue.openBlock(), vue.createElementBlock("tr", _hoisted_8, [
+              vue.createElementVNode("td", {
+                colspan: colspan.value,
+                class: "tx-data-table__empty"
+              }, [
+                vue.renderSlot(_ctx.$slots, "empty", {}, () => [
+                  vue.createVNode(vue.unref(index.TxEmptyState), {
+                    variant: "no-data",
+                    title: __props.emptyText,
+                    size: "small",
+                    layout: "vertical"
+                  }, null, 8, ["title"])
+                ], true)
+              ], 8, _hoisted_9)
+            ])) : vue.createCommentVNode("", true)
+          ])
+        ], 8, _hoisted_2)
+      ], 2);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/dist/lib/date-picker/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 TxDatePicker_vue_vue_type_script_setup_true_lang = require('./src/TxDatePicker.vue.js');
+
+const DatePicker = withInstall.withInstall(TxDatePicker_vue_vue_type_script_setup_true_lang.default);
+
+exports.TxDatePicker = TxDatePicker_vue_vue_type_script_setup_true_lang.default;
+exports.DatePicker = DatePicker;
+exports.default = DatePicker;

package/dist/lib/date-picker/src/TxDatePicker.vue.js

@@ -0,0 +1,194 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+const TxPicker = require('../../picker/src/TxPicker.vue.js');
+
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{ name: "TxDatePicker" },
+  __name: "TxDatePicker",
+  props: {
+    modelValue: { default: "" },
+    visible: { type: Boolean, default: false },
+    popup: { type: Boolean, default: true },
+    title: { default: "Select date" },
+    min: {},
+    max: {},
+    disabled: { type: Boolean, default: false },
+    showToolbar: { type: Boolean, default: true },
+    confirmText: { default: "Confirm" },
+    cancelText: { default: "Cancel" },
+    closeOnClickMask: { type: Boolean, default: true }
+  },
+  emits: ["update:modelValue", "change", "update:visible", "confirm", "cancel", "open", "close"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    function pad2(n) {
+      return n < 10 ? `0${n}` : String(n);
+    }
+    function formatYmd(y, m, d) {
+      return `${y}-${pad2(m)}-${pad2(d)}`;
+    }
+    function isValidDateParts(y, m, d) {
+      if (!Number.isFinite(y) || !Number.isFinite(m) || !Number.isFinite(d))
+        return false;
+      if (m < 1 || m > 12)
+        return false;
+      const max = new Date(y, m, 0).getDate();
+      return d >= 1 && d <= max;
+    }
+    function parseYmd(s) {
+      const raw = (s || "").trim();
+      if (!raw)
+        return null;
+      const m = raw.match(/^(\d{4})-(\d{1,2})-(\d{1,2})$/);
+      if (!m)
+        return null;
+      const y = Number(m[1]);
+      const mm = Number(m[2]);
+      const d = Number(m[3]);
+      if (!isValidDateParts(y, mm, d))
+        return null;
+      return { y, m: mm, d };
+    }
+    function toDateObj(p) {
+      return new Date(p.y, p.m - 1, p.d);
+    }
+    function clampDate(p, min, max) {
+      let y = p.y;
+      let m = p.m;
+      let d = p.d;
+      const maxDay = new Date(y, m, 0).getDate();
+      d = Math.min(Math.max(1, d), maxDay);
+      let dt = toDateObj({ y, m, d });
+      if (min && dt.getTime() < min.getTime()) {
+        y = min.getFullYear();
+        m = min.getMonth() + 1;
+        d = min.getDate();
+        dt = toDateObj({ y, m, d });
+      }
+      if (max && dt.getTime() > max.getTime()) {
+        y = max.getFullYear();
+        m = max.getMonth() + 1;
+        d = max.getDate();
+        dt = toDateObj({ y, m, d });
+      }
+      return { y, m, d };
+    }
+    const minDate = vue.computed(() => {
+      const p = parseYmd(props.min || "");
+      return p ? toDateObj(p) : null;
+    });
+    const maxDate = vue.computed(() => {
+      const p = parseYmd(props.max || "");
+      return p ? toDateObj(p) : null;
+    });
+    const localParts = vue.ref({ y: 2025, m: 1, d: 1 });
+    function setFromModel(v) {
+      const parsed = parseYmd(v);
+      const base = parsed ?? (() => {
+        const now = /* @__PURE__ */ new Date();
+        return { y: now.getFullYear(), m: now.getMonth() + 1, d: now.getDate() };
+      })();
+      localParts.value = clampDate(base, minDate.value, maxDate.value);
+    }
+    vue.watch(
+      () => props.modelValue,
+      (v) => setFromModel(v || ""),
+      { immediate: true }
+    );
+    vue.watch([minDate, maxDate], () => {
+      localParts.value = clampDate(localParts.value, minDate.value, maxDate.value);
+    });
+    const years = vue.computed(() => {
+      const minY = minDate.value?.getFullYear() ?? 1970;
+      const maxY = maxDate.value?.getFullYear() ?? 2100;
+      const from = Math.min(minY, maxY);
+      const to = Math.max(minY, maxY);
+      const out = [];
+      for (let y = from; y <= to; y++) out.push(y);
+      return out;
+    });
+    const pickerColumns = vue.computed(() => {
+      const { y, m } = localParts.value;
+      const min = minDate.value;
+      const max = maxDate.value;
+      const minY = min?.getFullYear() ?? null;
+      const minM = min ? min.getMonth() + 1 : null;
+      const minD = min ? min.getDate() : null;
+      const maxY = max?.getFullYear() ?? null;
+      const maxM = max ? max.getMonth() + 1 : null;
+      const maxD = max ? max.getDate() : null;
+      const yearOptions = years.value.map((yy) => ({
+        value: yy,
+        label: String(yy),
+        disabled: minY != null && yy < minY || maxY != null && yy > maxY
+      }));
+      const monthOptions = Array.from({ length: 12 }).map((_, i) => {
+        const mm = i + 1;
+        const disabled = minY != null && minM != null && y === minY && mm < minM || maxY != null && maxM != null && y === maxY && mm > maxM;
+        return { value: mm, label: pad2(mm), disabled };
+      });
+      const maxDay = new Date(y, m, 0).getDate();
+      const dayOptions = Array.from({ length: maxDay }).map((_, i) => {
+        const dd = i + 1;
+        const disabled = minY != null && minM != null && minD != null && y === minY && m === minM && dd < minD || maxY != null && maxM != null && maxD != null && y === maxY && m === maxM && dd > maxD;
+        return { value: dd, label: pad2(dd), disabled };
+      });
+      return [
+        { key: "year", options: yearOptions },
+        { key: "month", options: monthOptions },
+        { key: "day", options: dayOptions }
+      ];
+    });
+    const pickerValue = vue.computed({
+      get: () => [localParts.value.y, localParts.value.m, localParts.value.d],
+      set: (v) => {
+        const yy = Number(v[0]);
+        const mm = Number(v[1]);
+        const dd = Number(v[2]);
+        const next = clampDate({ y: yy, m: mm, d: dd }, minDate.value, maxDate.value);
+        localParts.value = next;
+        const s = formatYmd(next.y, next.m, next.d);
+        emit("update:modelValue", s);
+        emit("change", s);
+      }
+    });
+    const open = vue.computed({
+      get: () => !!props.visible,
+      set: (v) => emit("update:visible", v)
+    });
+    function onConfirm() {
+      const { y, m, d } = localParts.value;
+      const s = formatYmd(y, m, d);
+      emit("confirm", s);
+    }
+    function onCancel() {
+      emit("cancel");
+    }
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(TxPicker.default, {
+        modelValue: pickerValue.value,
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => pickerValue.value = $event),
+        visible: open.value,
+        "onUpdate:visible": _cache[1] || (_cache[1] = ($event) => open.value = $event),
+        columns: pickerColumns.value,
+        popup: __props.popup,
+        title: __props.title,
+        disabled: __props.disabled,
+        "show-toolbar": __props.showToolbar,
+        "confirm-text": __props.confirmText,
+        "cancel-text": __props.cancelText,
+        "close-on-click-mask": __props.closeOnClickMask,
+        onConfirm,
+        onCancel,
+        onOpen: _cache[2] || (_cache[2] = ($event) => _ctx.$emit("open")),
+        onClose: _cache[3] || (_cache[3] = ($event) => _ctx.$emit("close"))
+      }, null, 8, ["modelValue", "visible", "columns", "popup", "title", "disabled", "show-toolbar", "confirm-text", "cancel-text", "close-on-click-mask"]);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/dist/lib/date-picker/src/TxDatePicker.vue2.js

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

package/dist/lib/dialog/index.js

@@ -0,0 +1,26 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const withInstall = require('../utils/withInstall.js');
+const TxBlowDialog_vue_vue_type_script_setup_true_lang = require('./src/TxBlowDialog.vue.js');
+;/* empty css                       */
+const TxBottomDialog = require('./src/TxBottomDialog.vue.js');
+const TxPopperDialog_vue_vue_type_script_setup_true_lang = require('./src/TxPopperDialog.vue.js');
+;/* empty css                         */
+const TxTouchTip = require('./src/TxTouchTip.vue.js');
+
+const BottomDialog = withInstall.withInstall(TxBottomDialog.default);
+const BlowDialog = withInstall.withInstall(TxBlowDialog_vue_vue_type_script_setup_true_lang.default);
+const PopperDialog = withInstall.withInstall(TxPopperDialog_vue_vue_type_script_setup_true_lang.default);
+const TouchTip = withInstall.withInstall(TxTouchTip.default);
+
+exports.TxBlowDialog = TxBlowDialog_vue_vue_type_script_setup_true_lang.default;
+exports.TxBottomDialog = TxBottomDialog.default;
+exports.TxPopperDialog = TxPopperDialog_vue_vue_type_script_setup_true_lang.default;
+exports.TxTouchTip = TxTouchTip.default;
+exports.BlowDialog = BlowDialog;
+exports.BottomDialog = BottomDialog;
+exports.PopperDialog = PopperDialog;
+exports.TouchTip = TouchTip;
+exports.default = BottomDialog;

package/dist/lib/dialog/src/TxBlowDialog.vue.js

@@ -0,0 +1,144 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+
+const _hoisted_1 = ["aria-labelledby"];
+const _hoisted_2 = { class: "tx-blow-dialog__container" };
+const _hoisted_3 = {
+  key: 0,
+  id: "tx-blow-dialog-title",
+  class: "tx-blow-dialog__title"
+};
+const _hoisted_4 = { class: "tx-blow-dialog__content" };
+const _hoisted_5 = ["innerHTML"];
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{
+    name: "TxBlowDialog"
+  },
+  __name: "TxBlowDialog",
+  props: {
+    close: {
+      type: Function,
+      required: true
+    },
+    title: {
+      type: String,
+      default: ""
+    },
+    message: {
+      type: String,
+      default: ""
+    },
+    comp: {
+      type: Object,
+      default: void 0
+    },
+    render: {
+      type: Function,
+      default: void 0
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const isClosing = vue.ref(false);
+    const renderComp = vue.ref(null);
+    const dialogWrapper = vue.ref(null);
+    let previouslyFocusedElement = null;
+    let didApplyBackgroundBlur = false;
+    function sleep(ms) {
+      return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    vue.onMounted(() => {
+      previouslyFocusedElement = document.activeElement;
+      if (props.render) {
+        renderComp.value = vue.defineComponent({
+          render: props.render
+        });
+      }
+      applyBackgroundBlur(true);
+      setFocusToDialog();
+    });
+    vue.onUnmounted(() => {
+      restoreFocus();
+    });
+    function setFocusToDialog() {
+      const confirmButton = dialogWrapper.value?.querySelector(".tx-blow-dialog__confirm");
+      if (confirmButton instanceof HTMLElement) {
+        confirmButton.focus();
+      } else if (dialogWrapper.value) {
+        dialogWrapper.value.setAttribute("tabindex", "-1");
+        dialogWrapper.value.focus();
+      }
+    }
+    function restoreFocus() {
+      if (previouslyFocusedElement) {
+        previouslyFocusedElement.focus();
+      }
+    }
+    function applyBackgroundBlur(apply) {
+      const isVitePress = !!document.querySelector(".VPApp");
+      if (isVitePress)
+        return;
+      const app = document.getElementById("app");
+      if (!app)
+        return;
+      if (apply) {
+        Object.assign(app.style, {
+          transition: ".75s",
+          transform: "scale(1.25)",
+          opacity: ".75"
+        });
+        didApplyBackgroundBlur = true;
+      } else {
+        Object.assign(app.style, {
+          transform: "scale(1)",
+          opacity: "1"
+        });
+      }
+    }
+    async function destroy() {
+      applyBackgroundBlur(false);
+      isClosing.value = true;
+      await sleep(550);
+      if (didApplyBackgroundBlur) {
+        const app = document.getElementById("app");
+        if (app) {
+          app.style.cssText = "";
+        }
+      }
+      props.close();
+    }
+    vue.provide("destroy", destroy);
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.Teleport, { to: "body" }, [
+        vue.createElementVNode("div", {
+          ref_key: "dialogWrapper",
+          ref: dialogWrapper,
+          class: vue.normalizeClass(["tx-blow-dialog", { "tx-blow-dialog--closing": isClosing.value }]),
+          role: "dialog",
+          "aria-modal": "true",
+          "aria-labelledby": __props.title ? "tx-blow-dialog-title" : void 0,
+          onKeydown: vue.withKeys(destroy, ["esc"])
+        }, [
+          vue.createElementVNode("div", _hoisted_2, [
+            renderComp.value ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(renderComp.value), { key: 0 })) : __props.comp ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(__props.comp), { key: 1 })) : (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 2 }, [
+              __props.title ? (vue.openBlock(), vue.createElementBlock("p", _hoisted_3, vue.toDisplayString(__props.title), 1)) : vue.createCommentVNode("", true),
+              vue.createElementVNode("div", _hoisted_4, [
+                vue.createElementVNode("span", { innerHTML: __props.message }, null, 8, _hoisted_5)
+              ]),
+              vue.createElementVNode("button", {
+                type: "button",
+                class: "tx-blow-dialog__confirm",
+                onClick: destroy
+              }, " Confirm ")
+            ], 64))
+          ])
+        ], 42, _hoisted_1)
+      ]);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/dist/lib/dialog/src/TxBlowDialog.vue3.js

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