@talex-touch/tuffex 0.3.3

package/dist/lib/container/src/TxRow.vue2.js

@@ -0,0 +1,91 @@
+'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: "TxRow" },
+  __name: "TxRow",
+  props: {
+    gutter: { default: 0 },
+    align: { default: "stretch" },
+    justify: { default: "start" },
+    wrap: { type: Boolean, default: true }
+  },
+  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 resolveGutter(g) {
+      if (typeof g === "number")
+        return Math.max(0, g);
+      const bp = getBp(width.value);
+      const v = g[bp] ?? g.md ?? g.sm ?? g.xs ?? 0;
+      return Math.max(0, Number(v));
+    }
+    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);
+      }
+    });
+    const gutterPx = vue.computed(() => resolveGutter(props.gutter));
+    const style = vue.computed(() => {
+      const g = gutterPx.value;
+      return {
+        "--tx-row-gutter": `${g}px`
+      };
+    });
+    const cls = vue.computed(() => {
+      const alignMap = {
+        top: "flex-start",
+        middle: "center",
+        bottom: "flex-end",
+        stretch: "stretch"
+      };
+      const justifyMap = {
+        "start": "flex-start",
+        "end": "flex-end",
+        "center": "center",
+        "space-around": "space-around",
+        "space-between": "space-between",
+        "space-evenly": "space-evenly"
+      };
+      return {
+        align: alignMap[props.align] ?? "stretch",
+        justify: justifyMap[props.justify] ?? "flex-start"
+      };
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: "tx-row",
+        style: vue.normalizeStyle([style.value, { alignItems: cls.value.align, justifyContent: cls.value.justify, flexWrap: __props.wrap ? "wrap" : "nowrap" }])
+      }, [
+        vue.renderSlot(_ctx.$slots, "default", {}, void 0, true)
+      ], 4);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/dist/lib/context-menu/index.js

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

package/dist/lib/context-menu/src/TxContextMenu.vue.js

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

package/dist/lib/context-menu/src/TxContextMenu.vue2.js

@@ -0,0 +1,173 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+const vue$1 = require('@floating-ui/vue');
+
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{ name: "TxContextMenu" },
+  __name: "TxContextMenu",
+  props: {
+    modelValue: { type: Boolean, default: void 0 },
+    x: { default: 0 },
+    y: { default: 0 },
+    width: { default: 220 },
+    closeOnEsc: { type: Boolean, default: true },
+    closeOnClickOutside: { type: Boolean, default: true }
+  },
+  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 (typeof props.modelValue !== "boolean")
+          internalOpen.value = v;
+        emit("update:modelValue", v);
+        if (v)
+          emit("open", { x: point.value.x, y: point.value.y });
+        else
+          emit("close");
+      }
+    });
+    const triggerRef = vue.ref(null);
+    const menuRef = vue.ref(null);
+    const point = vue.ref({ x: props.x, y: props.y });
+    const lastOpenedAt = vue.ref(0);
+    const virtualReference = vue.computed(() => {
+      return {
+        getBoundingClientRect() {
+          return {
+            x: point.value.x,
+            y: point.value.y,
+            top: point.value.y,
+            left: point.value.x,
+            right: point.value.x,
+            bottom: point.value.y,
+            width: 0,
+            height: 0
+          };
+        }
+      };
+    });
+    const cleanupAutoUpdate = vue.ref(null);
+    const { floatingStyles, update } = vue$1.useFloating(virtualReference, menuRef, {
+      placement: "bottom-start",
+      strategy: "fixed",
+      middleware: [vue$1.flip({ padding: 8 }), vue$1.shift({ padding: 8 })]
+    });
+    function close() {
+      open.value = false;
+    }
+    vue.provide("txContextMenu", {
+      close
+    });
+    function onContextMenu(e) {
+      e.preventDefault();
+      point.value = { x: e.clientX, y: e.clientY };
+      lastOpenedAt.value = performance.now();
+      open.value = true;
+    }
+    vue.watch(
+      () => [props.x, props.y],
+      ([x, y]) => {
+        point.value = { x: x ?? 0, y: y ?? 0 };
+      }
+    );
+    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 (!open.value)
+        return;
+      if (performance.now() - lastOpenedAt.value < 60)
+        return;
+      const inTrigger = isEventInside(e, triggerRef.value);
+      const inMenu = isEventInside(e, menuRef.value);
+      if (!inTrigger && !inMenu)
+        close();
+    }
+    function handleEsc(e) {
+      if (!props.closeOnEsc)
+        return;
+      if (e.key !== "Escape")
+        return;
+      if (!open.value)
+        return;
+      close();
+    }
+    vue.watch(
+      open,
+      async (v) => {
+        if (!v) {
+          cleanupAutoUpdate.value?.();
+          cleanupAutoUpdate.value = null;
+          return;
+        }
+        await vue.nextTick();
+        await update();
+        if (menuRef.value) {
+          cleanupAutoUpdate.value?.();
+          cleanupAutoUpdate.value = vue$1.autoUpdate(document.documentElement, menuRef.value, () => update());
+        }
+      },
+      { flush: "post" }
+    );
+    vue.onMounted(() => {
+      document.addEventListener("pointerdown", handleOutside, true);
+      document.addEventListener("keydown", handleEsc);
+    });
+    vue.onBeforeUnmount(() => {
+      document.removeEventListener("pointerdown", handleOutside, true);
+      document.removeEventListener("keydown", handleEsc);
+      cleanupAutoUpdate.value?.();
+      cleanupAutoUpdate.value = null;
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock(vue.Fragment, null, [
+        vue.createElementVNode("div", {
+          ref_key: "triggerRef",
+          ref: triggerRef,
+          class: "tx-context-menu__trigger",
+          onContextmenu: onContextMenu
+        }, [
+          vue.renderSlot(_ctx.$slots, "trigger", {}, () => [
+            vue.renderSlot(_ctx.$slots, "default", {}, void 0, true)
+          ], true)
+        ], 544),
+        (vue.openBlock(), vue.createBlock(vue.Teleport, { to: "body" }, [
+          vue.createVNode(vue.Transition, { name: "tx-context-menu" }, {
+            default: vue.withCtx(() => [
+              vue.withDirectives(vue.createElementVNode("div", {
+                ref_key: "menuRef",
+                ref: menuRef,
+                class: "tx-context-menu",
+                style: vue.normalizeStyle([vue.unref(floatingStyles), { width: `${__props.width}px` }]),
+                role: "menu"
+              }, [
+                vue.renderSlot(_ctx.$slots, "menu", {}, void 0, true)
+              ], 4), [
+                [vue.vShow, open.value]
+              ])
+            ]),
+            _: 3
+          })
+        ]))
+      ], 64);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/dist/lib/context-menu/src/TxContextMenuItem.vue.js

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

package/dist/lib/context-menu/src/TxContextMenuItem.vue2.js

@@ -0,0 +1,43 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+const TxCardItem = require('../../card-item/src/TxCardItem.vue.js');
+
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{ name: "TxContextMenuItem" },
+  __name: "TxContextMenuItem",
+  props: {
+    disabled: { type: Boolean, default: false },
+    danger: { type: Boolean, default: false }
+  },
+  emits: ["select"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const ctx = vue.inject("txContextMenu", null);
+    function onClick() {
+      if (props.disabled)
+        return;
+      emit("select");
+      ctx?.close?.();
+    }
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(TxCardItem.default, {
+        class: vue.normalizeClass(["tx-context-menu-item", { "is-disabled": __props.disabled, "is-danger": __props.danger }]),
+        role: "menuitem",
+        clickable: !__props.disabled,
+        disabled: __props.disabled,
+        onClick
+      }, {
+        title: vue.withCtx(() => [
+          vue.renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ]),
+        _: 3
+      }, 8, ["class", "clickable", "disabled"]);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/dist/lib/corner-overlay/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 TxCornerOverlay = require('./src/TxCornerOverlay.vue.js');
+
+const CornerOverlay = withInstall.withInstall(TxCornerOverlay.default);
+
+exports.TxCornerOverlay = TxCornerOverlay.default;
+exports.CornerOverlay = CornerOverlay;
+exports.default = CornerOverlay;

package/dist/lib/corner-overlay/src/TxCornerOverlay.vue.js

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

package/dist/lib/corner-overlay/src/TxCornerOverlay.vue2.js

@@ -0,0 +1,67 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+
+const _hoisted_1 = { class: "tx-corner-overlay" };
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{
+    name: "TxCornerOverlay"
+  },
+  __name: "TxCornerOverlay",
+  props: {
+    placement: { default: "bottom-right" },
+    offsetX: { default: 0 },
+    offsetY: { default: 0 },
+    overlayPointerEvents: { default: "none" }
+  },
+  setup(__props) {
+    const props = __props;
+    function toCssUnit(value) {
+      return typeof value === "number" ? `${value}px` : value;
+    }
+    const overlayStyle = vue.computed(() => {
+      const x = toCssUnit(props.offsetX);
+      const y = toCssUnit(props.offsetY);
+      const style = {
+        pointerEvents: props.overlayPointerEvents
+      };
+      switch (props.placement) {
+        case "top-left":
+          style.top = y;
+          style.left = x;
+          break;
+        case "top-right":
+          style.top = y;
+          style.right = x;
+          break;
+        case "bottom-left":
+          style.bottom = y;
+          style.left = x;
+          break;
+        case "bottom-right":
+        default:
+          style.bottom = y;
+          style.right = x;
+          break;
+      }
+      return style;
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("span", _hoisted_1, [
+        vue.renderSlot(_ctx.$slots, "default", {}, void 0, true),
+        _ctx.$slots.overlay ? (vue.openBlock(), vue.createElementBlock("span", {
+          key: 0,
+          class: "tx-corner-overlay__overlay",
+          style: vue.normalizeStyle(overlayStyle.value),
+          "aria-hidden": "true"
+        }, [
+          vue.renderSlot(_ctx.$slots, "overlay", {}, void 0, true)
+        ], 4)) : vue.createCommentVNode("", true)
+      ]);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/dist/lib/data-table/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 TxDataTable = require('./src/TxDataTable.vue.js');
+
+const DataTable = withInstall.withInstall(TxDataTable.default);
+
+exports.TxDataTable = TxDataTable.default;
+exports.DataTable = DataTable;
+exports.default = DataTable;

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

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