@talex-touch/tuffex 0.3.3

package/dist/lib/picker/src/TxPicker.vue2.js

@@ -0,0 +1,407 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+
+const _hoisted_1 = {
+  key: 0,
+  class: "tx-picker__toolbar"
+};
+const _hoisted_2 = ["disabled"];
+const _hoisted_3 = { class: "tx-picker__title" };
+const _hoisted_4 = ["disabled"];
+const _hoisted_5 = ["onScrollPassive"];
+const _hoisted_6 = ["disabled", "onClick"];
+const _hoisted_7 = {
+  key: 0,
+  class: "tx-picker__toolbar"
+};
+const _hoisted_8 = ["disabled"];
+const _hoisted_9 = { class: "tx-picker__title" };
+const _hoisted_10 = ["disabled"];
+const _hoisted_11 = ["onScrollPassive"];
+const _hoisted_12 = ["disabled", "onClick"];
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{ name: "TxPicker" },
+  __name: "TxPicker",
+  props: {
+    modelValue: { default: () => [] },
+    columns: { default: () => [] },
+    visible: { type: Boolean, default: false },
+    popup: { type: Boolean, default: true },
+    title: { default: "" },
+    showToolbar: { type: Boolean, default: true },
+    confirmText: { default: "Confirm" },
+    cancelText: { default: "Cancel" },
+    disabled: { type: Boolean, default: false },
+    itemHeight: { default: 36 },
+    visibleItemCount: { default: 5 },
+    closeOnClickMask: { type: Boolean, default: true },
+    lazyMount: { type: Boolean, default: true }
+  },
+  emits: ["update:modelValue", "change", "update:visible", "confirm", "cancel", "open", "close"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const open = vue.computed({
+      get: () => !!props.visible,
+      set: (v) => emit("update:visible", v)
+    });
+    const mountedOnce = vue.ref(false);
+    const columns = vue.computed(() => props.columns ?? []);
+    const itemHeightPx = vue.computed(() => Math.max(24, props.itemHeight ?? 36));
+    const visibleCount = vue.computed(() => {
+      const n = Math.floor(props.visibleItemCount ?? 5);
+      return Math.max(3, n % 2 === 0 ? n + 1 : n);
+    });
+    const paddingY = vue.computed(() => (visibleCount.value - 1) / 2 * itemHeightPx.value);
+    const localValue = vue.ref([]);
+    function normalizeValue(v) {
+      const cols = columns.value;
+      const out = [];
+      for (let i = 0; i < cols.length; i++) {
+        const col = cols[i];
+        if (!col)
+          continue;
+        const opts = col.options ?? [];
+        const desired = v[i];
+        if (desired !== void 0) {
+          const idx = opts.findIndex((o) => o.value === desired);
+          if (idx >= 0) {
+            out[i] = desired;
+            continue;
+          }
+        }
+        const first = opts.find((o) => !o.disabled);
+        out[i] = first?.value ?? "";
+      }
+      return out;
+    }
+    vue.watch(
+      () => props.modelValue,
+      (v) => {
+        localValue.value = normalizeValue(Array.isArray(v) ? v : []);
+      },
+      { immediate: true }
+    );
+    vue.watch(
+      columns,
+      () => {
+        localValue.value = normalizeValue(localValue.value);
+      },
+      { flush: "sync" }
+    );
+    const colRefs = vue.ref([]);
+    const isDragging = vue.ref(false);
+    const scrollStates = vue.ref([]);
+    function ensureStates() {
+      const n = columns.value.length;
+      if (scrollStates.value.length === n)
+        return;
+      scrollStates.value = Array.from({ length: n }).map(() => ({ rafId: null, debounceId: null }));
+    }
+    function getIndexForValue(colIndex, v) {
+      const opts = columns.value[colIndex]?.options ?? [];
+      const idx = opts.findIndex((o) => o.value === v);
+      return Math.max(0, idx);
+    }
+    function clampIndex(colIndex, idx) {
+      const len = (columns.value[colIndex]?.options ?? []).length;
+      if (len <= 0)
+        return 0;
+      return Math.min(len - 1, Math.max(0, idx));
+    }
+    function scrollToIndex(colIndex, idx, behavior = "auto") {
+      const el = colRefs.value[colIndex];
+      if (!el)
+        return;
+      const top = idx * itemHeightPx.value;
+      el.scrollTo({ top, behavior });
+    }
+    function pickIndexFromScroll(colIndex) {
+      const el = colRefs.value[colIndex];
+      if (!el)
+        return;
+      const raw = el.scrollTop / itemHeightPx.value;
+      const idx = clampIndex(colIndex, Math.round(raw));
+      const opts = columns.value[colIndex]?.options ?? [];
+      const option = opts[idx];
+      if (option?.disabled) {
+        const next = opts.findIndex((o, i) => i >= idx && !o.disabled);
+        const prev = [...opts].reverse().findIndex((o) => !o.disabled);
+        const prevIdx = prev >= 0 ? opts.length - 1 - prev : -1;
+        const fallback = next >= 0 ? next : prevIdx;
+        if (fallback >= 0 && fallback !== idx) {
+          scrollToIndex(colIndex, fallback, "smooth");
+          setValueAt(colIndex, opts[fallback]?.value);
+          return;
+        }
+      }
+      setValueAt(colIndex, option?.value);
+    }
+    function settleScroll(colIndex) {
+      const el = colRefs.value[colIndex];
+      if (!el)
+        return;
+      const idx = clampIndex(colIndex, Math.round(el.scrollTop / itemHeightPx.value));
+      scrollToIndex(colIndex, idx, "smooth");
+    }
+    function setValueAt(colIndex, v) {
+      const next = localValue.value.slice();
+      next[colIndex] = v;
+      localValue.value = normalizeValue(next);
+      emit("update:modelValue", localValue.value);
+      emit("change", localValue.value);
+    }
+    function onScroll(colIndex) {
+      ensureStates();
+      const state = scrollStates.value[colIndex];
+      if (!state)
+        return;
+      if (state.rafId != null)
+        cancelAnimationFrame(state.rafId);
+      state.rafId = requestAnimationFrame(() => {
+        state.rafId = null;
+        pickIndexFromScroll(colIndex);
+      });
+      if (state.debounceId != null)
+        window.clearTimeout(state.debounceId);
+      state.debounceId = window.setTimeout(() => {
+        state.debounceId = null;
+        if (!isDragging.value)
+          settleScroll(colIndex);
+      }, 120);
+    }
+    function onPointerDown() {
+      if (props.disabled)
+        return;
+      isDragging.value = true;
+    }
+    function onPointerUp() {
+      if (!isDragging.value)
+        return;
+      isDragging.value = false;
+      for (let i = 0; i < columns.value.length; i++) settleScroll(i);
+    }
+    async function syncScrollPositions(behavior = "auto") {
+      await vue.nextTick();
+      ensureStates();
+      const v = localValue.value;
+      for (let i = 0; i < columns.value.length; i++) {
+        const idx = getIndexForValue(i, v[i]);
+        scrollToIndex(i, idx, behavior);
+      }
+    }
+    vue.watch(
+      open,
+      async (v) => {
+        if (v) {
+          emit("open");
+          mountedOnce.value = true;
+          await syncScrollPositions("auto");
+          return;
+        }
+        emit("close");
+      },
+      { flush: "post" }
+    );
+    vue.watch(
+      () => props.modelValue,
+      () => {
+        if (!open.value && props.popup)
+          return;
+        syncScrollPositions("auto");
+      }
+    );
+    vue.watch(
+      columns,
+      () => {
+        if (!open.value && props.popup)
+          return;
+        syncScrollPositions("auto");
+      }
+    );
+    function close() {
+      open.value = false;
+    }
+    function onMaskClick() {
+      if (!props.closeOnClickMask)
+        return;
+      close();
+    }
+    function onCancel() {
+      emit("cancel");
+      close();
+    }
+    function onConfirm() {
+      emit("confirm", localValue.value);
+      close();
+    }
+    __expose({
+      open: () => open.value = true,
+      close,
+      toggle: () => open.value = !open.value
+    });
+    vue.onBeforeUnmount(() => {
+      for (const s of scrollStates.value) {
+        if (s.rafId != null)
+          cancelAnimationFrame(s.rafId);
+        if (s.debounceId != null)
+          window.clearTimeout(s.debounceId);
+      }
+    });
+    return (_ctx, _cache) => {
+      return !__props.popup ? (vue.openBlock(), vue.createElementBlock("div", {
+        key: 0,
+        class: vue.normalizeClass(["tx-picker", { "is-disabled": __props.disabled }])
+      }, [
+        __props.showToolbar ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
+          vue.createElementVNode("button", {
+            type: "button",
+            class: "tx-picker__btn",
+            disabled: __props.disabled,
+            onClick: onCancel
+          }, vue.toDisplayString(__props.cancelText), 9, _hoisted_2),
+          vue.createElementVNode("div", _hoisted_3, vue.toDisplayString(__props.title), 1),
+          vue.createElementVNode("button", {
+            type: "button",
+            class: "tx-picker__btn is-primary",
+            disabled: __props.disabled,
+            onClick: onConfirm
+          }, vue.toDisplayString(__props.confirmText), 9, _hoisted_4)
+        ])) : vue.createCommentVNode("", true),
+        vue.createElementVNode("div", {
+          class: "tx-picker__columns",
+          style: vue.normalizeStyle({ "--tx-picker-item-height": `${itemHeightPx.value}px`, "--tx-picker-padding-y": `${paddingY.value}px` })
+        }, [
+          _cache[2] || (_cache[2] = vue.createElementVNode("div", {
+            class: "tx-picker__highlight",
+            "aria-hidden": "true"
+          }, null, -1)),
+          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(columns.value, (col, colIndex) => {
+            return vue.openBlock(), vue.createElementBlock("div", {
+              key: col.key ?? colIndex,
+              class: "tx-picker__col"
+            }, [
+              vue.createElementVNode("div", {
+                ref_for: true,
+                ref: (el) => colRefs.value[colIndex] = el,
+                class: "tx-picker__scroller",
+                role: "listbox",
+                tabindex: "-1",
+                onScrollPassive: ($event) => onScroll(colIndex),
+                onPointerdown: onPointerDown,
+                onPointerup: onPointerUp,
+                onPointercancel: onPointerUp
+              }, [
+                _cache[0] || (_cache[0] = vue.createElementVNode("div", {
+                  class: "tx-picker__pad",
+                  "aria-hidden": "true"
+                }, null, -1)),
+                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(col.options, (opt) => {
+                  return vue.openBlock(), vue.createElementBlock("button", {
+                    key: String(opt.value),
+                    type: "button",
+                    class: vue.normalizeClass(["tx-picker__item", { "is-disabled": !!opt.disabled, "is-selected": localValue.value[colIndex] === opt.value }]),
+                    disabled: __props.disabled || !!opt.disabled,
+                    onClick: ($event) => scrollToIndex(colIndex, clampIndex(colIndex, col.options.findIndex((o) => o.value === opt.value)), "smooth")
+                  }, vue.toDisplayString(opt.label), 11, _hoisted_6);
+                }), 128)),
+                _cache[1] || (_cache[1] = vue.createElementVNode("div", {
+                  class: "tx-picker__pad",
+                  "aria-hidden": "true"
+                }, null, -1))
+              ], 40, _hoisted_5)
+            ]);
+          }), 128))
+        ], 4)
+      ], 2)) : (vue.openBlock(), vue.createBlock(vue.Teleport, {
+        key: 1,
+        to: "body"
+      }, [
+        vue.createVNode(vue.Transition, { name: "tx-picker-popup" }, {
+          default: vue.withCtx(() => [
+            open.value && (!__props.lazyMount || mountedOnce.value) ? (vue.openBlock(), vue.createElementBlock("div", {
+              key: 0,
+              class: "tx-picker-popup",
+              onPointerup: onPointerUp
+            }, [
+              vue.createElementVNode("div", {
+                class: "tx-picker-popup__mask",
+                onClick: onMaskClick
+              }),
+              vue.createElementVNode("div", {
+                class: vue.normalizeClass(["tx-picker-popup__panel", { "is-disabled": __props.disabled }])
+              }, [
+                __props.showToolbar ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_7, [
+                  vue.createElementVNode("button", {
+                    type: "button",
+                    class: "tx-picker__btn",
+                    disabled: __props.disabled,
+                    onClick: onCancel
+                  }, vue.toDisplayString(__props.cancelText), 9, _hoisted_8),
+                  vue.createElementVNode("div", _hoisted_9, vue.toDisplayString(__props.title), 1),
+                  vue.createElementVNode("button", {
+                    type: "button",
+                    class: "tx-picker__btn is-primary",
+                    disabled: __props.disabled,
+                    onClick: onConfirm
+                  }, vue.toDisplayString(__props.confirmText), 9, _hoisted_10)
+                ])) : vue.createCommentVNode("", true),
+                vue.createElementVNode("div", {
+                  class: "tx-picker__columns",
+                  style: vue.normalizeStyle({ "--tx-picker-item-height": `${itemHeightPx.value}px`, "--tx-picker-padding-y": `${paddingY.value}px` })
+                }, [
+                  _cache[5] || (_cache[5] = vue.createElementVNode("div", {
+                    class: "tx-picker__highlight",
+                    "aria-hidden": "true"
+                  }, null, -1)),
+                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(columns.value, (col, colIndex) => {
+                    return vue.openBlock(), vue.createElementBlock("div", {
+                      key: col.key ?? colIndex,
+                      class: "tx-picker__col"
+                    }, [
+                      vue.createElementVNode("div", {
+                        ref_for: true,
+                        ref: (el) => colRefs.value[colIndex] = el,
+                        class: "tx-picker__scroller",
+                        role: "listbox",
+                        tabindex: "-1",
+                        onScrollPassive: ($event) => onScroll(colIndex),
+                        onPointerdown: onPointerDown,
+                        onPointerup: onPointerUp,
+                        onPointercancel: onPointerUp
+                      }, [
+                        _cache[3] || (_cache[3] = vue.createElementVNode("div", {
+                          class: "tx-picker__pad",
+                          "aria-hidden": "true"
+                        }, null, -1)),
+                        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(col.options, (opt) => {
+                          return vue.openBlock(), vue.createElementBlock("button", {
+                            key: String(opt.value),
+                            type: "button",
+                            class: vue.normalizeClass(["tx-picker__item", { "is-disabled": !!opt.disabled, "is-selected": localValue.value[colIndex] === opt.value }]),
+                            disabled: __props.disabled || !!opt.disabled,
+                            onClick: ($event) => scrollToIndex(colIndex, clampIndex(colIndex, col.options.findIndex((o) => o.value === opt.value)), "smooth")
+                          }, vue.toDisplayString(opt.label), 11, _hoisted_12);
+                        }), 128)),
+                        _cache[4] || (_cache[4] = vue.createElementVNode("div", {
+                          class: "tx-picker__pad",
+                          "aria-hidden": "true"
+                        }, null, -1))
+                      ], 40, _hoisted_11)
+                    ]);
+                  }), 128))
+                ], 4)
+              ], 2)
+            ], 32)) : vue.createCommentVNode("", true)
+          ]),
+          _: 1
+        })
+      ]));
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/dist/lib/popover/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 TxPopover = require('./src/TxPopover.vue.js');
+
+const Popover = withInstall.withInstall(TxPopover.default);
+
+exports.TxPopover = TxPopover.default;
+exports.Popover = Popover;
+exports.default = Popover;

package/dist/lib/popover/src/TxPopover.vue.js

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