@talex-touch/tuffex 0.3.3

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

@@ -0,0 +1,81 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+const TxAutoSizer_vue_vue_type_script_setup_true_lang = require('../../auto-sizer/src/TxAutoSizer.vue.js');
+
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{
+    name: "TxTransitionSmoothSize",
+    inheritAttrs: false
+  },
+  __name: "TxTransitionSmoothSize",
+  props: {
+    appear: { type: Boolean, default: true },
+    mode: { default: "out-in" },
+    duration: { default: 220 },
+    easing: { default: "cubic-bezier(0.2, 0, 0, 1)" },
+    width: { type: Boolean, default: false },
+    height: { type: Boolean, default: true },
+    motion: { default: "fade" }
+  },
+  setup(__props) {
+    const props = __props;
+    const attrs = vue.useAttrs();
+    const name = vue.computed(() => {
+      if (props.motion === "slide-fade")
+        return "tx-slide-fade";
+      if (props.motion === "rebound")
+        return "tx-rebound";
+      return "tx-fade";
+    });
+    const styleVars = vue.computed(() => {
+      return {
+        "--tx-transition-duration": `${props.duration}ms`,
+        "--tx-transition-easing": props.easing
+      };
+    });
+    const wrapperClass = vue.computed(() => {
+      return ["tx-transition", "tx-transition-smooth-size", attrs.class];
+    });
+    const wrapperStyle = vue.computed(() => {
+      return [styleVars.value, attrs.style];
+    });
+    const passThroughAttrs = vue.computed(() => {
+      const { class: _c, style: _s, ...rest } = attrs;
+      return rest;
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(TxAutoSizer_vue_vue_type_script_setup_true_lang.default, vue.mergeProps({
+        class: "tx-transition-smooth-size__outer",
+        width: __props.width,
+        height: __props.height,
+        "duration-ms": __props.duration,
+        easing: __props.easing,
+        "outer-class": "overflow-hidden"
+      }, passThroughAttrs.value), {
+        default: vue.withCtx(() => [
+          vue.createElementVNode("div", {
+            class: vue.normalizeClass(wrapperClass.value),
+            style: vue.normalizeStyle(wrapperStyle.value)
+          }, [
+            vue.createVNode(vue.Transition, {
+              name: name.value,
+              appear: __props.appear,
+              mode: __props.mode
+            }, {
+              default: vue.withCtx(() => [
+                vue.renderSlot(_ctx.$slots, "default")
+              ]),
+              _: 3
+            }, 8, ["name", "appear", "mode"])
+          ], 6)
+        ]),
+        _: 3
+      }, 16, ["width", "height", "duration-ms", "easing"]);
+    };
+  }
+});
+
+exports.default = _sfc_main;

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

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

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

package/dist/lib/tree/src/TxTree.vue.js

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

package/dist/lib/tree/src/TxTree.vue2.js

@@ -0,0 +1,241 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+require('../../checkbox/index.js');
+const index = require('../../icon/index.js');
+const TxCheckbox = require('../../checkbox/src/TxCheckbox.vue.js');
+
+const _hoisted_1 = {
+  class: "tx-tree",
+  role: "tree"
+};
+const _hoisted_2 = {
+  key: 0,
+  class: "tx-tree__empty"
+};
+const _hoisted_3 = {
+  key: 1,
+  class: "tx-tree__list"
+};
+const _hoisted_4 = ["aria-expanded", "aria-selected", "onClick"];
+const _hoisted_5 = ["aria-label", "onClick"];
+const _hoisted_6 = {
+  key: 1,
+  class: "tx-tree__caret-placeholder",
+  "aria-hidden": "true"
+};
+const _hoisted_7 = { class: "tx-tree__label" };
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{ name: "TxTree" },
+  __name: "TxTree",
+  props: {
+    nodes: { default: () => [] },
+    modelValue: {},
+    multiple: { type: Boolean, default: false },
+    selectable: { type: Boolean, default: true },
+    checkable: { type: Boolean, default: false },
+    disabled: { type: Boolean, default: false },
+    defaultExpandedKeys: { default: () => [] },
+    expandedKeys: {},
+    indent: { default: 16 },
+    filterText: {},
+    filterMethod: {}
+  },
+  emits: ["update:modelValue", "select", "toggle", "update:expandedKeys"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const internalExpanded = vue.ref(new Set(props.defaultExpandedKeys ?? []));
+    vue.watch(
+      () => props.defaultExpandedKeys,
+      (next) => {
+        if (props.expandedKeys !== void 0)
+          return;
+        internalExpanded.value = new Set(next ?? []);
+      }
+    );
+    const expandedSet = vue.computed(() => {
+      if (props.expandedKeys !== void 0)
+        return new Set(props.expandedKeys);
+      return internalExpanded.value;
+    });
+    const selectedSet = vue.computed(() => {
+      const v = props.modelValue;
+      if (props.multiple) {
+        const list = Array.isArray(v) ? v : [];
+        return new Set(list);
+      }
+      if (typeof v === "string" || typeof v === "number")
+        return /* @__PURE__ */ new Set([v]);
+      return /* @__PURE__ */ new Set();
+    });
+    function resolveIcon(icon) {
+      if (!icon)
+        return void 0;
+      if (typeof icon === "string") {
+        return { type: "class", value: icon };
+      }
+      return icon;
+    }
+    function setExpanded(next) {
+      if (props.expandedKeys === void 0)
+        internalExpanded.value = next;
+      emit("update:expandedKeys", Array.from(next));
+    }
+    function toggleExpand(node) {
+      if (!node.children?.length)
+        return;
+      const next = new Set(expandedSet.value);
+      const isExpanded = next.has(node.key);
+      if (isExpanded)
+        next.delete(node.key);
+      else next.add(node.key);
+      setExpanded(next);
+      emit("toggle", { key: node.key, expanded: !isExpanded });
+    }
+    function emitSelection(value, node) {
+      emit("update:modelValue", value);
+      emit("select", { key: node.key, node });
+    }
+    function toggleSelect(node) {
+      if (!props.selectable || props.disabled || node.disabled)
+        return;
+      if (props.multiple) {
+        const next = new Set(selectedSet.value);
+        if (next.has(node.key))
+          next.delete(node.key);
+        else next.add(node.key);
+        emitSelection(Array.from(next), node);
+        return;
+      }
+      emitSelection(node.key, node);
+    }
+    function filterTree(nodes, rawQuery) {
+      const query = rawQuery.trim();
+      if (!query)
+        return { nodes, expandKeys: /* @__PURE__ */ new Set() };
+      const lowered = query.toLowerCase();
+      const expandKeys = /* @__PURE__ */ new Set();
+      const match = props.filterMethod;
+      const defaultMatch = (node, q) => (node.label ?? "").toLowerCase().includes(q);
+      const loop = (list, ancestors) => {
+        const out = [];
+        for (const node of list) {
+          const selfMatch = match ? match(node, query) : defaultMatch(node, lowered);
+          const children = node.children?.length ? loop(node.children, [...ancestors, node.key]) : [];
+          const hit = selfMatch || children.length > 0;
+          if (!hit)
+            continue;
+          if (ancestors.length)
+            ancestors.forEach((k) => expandKeys.add(k));
+          if (children.length)
+            expandKeys.add(node.key);
+          out.push({ ...node, children: children.length ? children : node.children });
+        }
+        return out;
+      };
+      return { nodes: loop(nodes, []), expandKeys };
+    }
+    const filtered = vue.computed(() => filterTree(props.nodes, props.filterText ?? ""));
+    const effectiveExpanded = vue.computed(() => {
+      if (!props.filterText?.trim())
+        return expandedSet.value;
+      const next = new Set(expandedSet.value);
+      filtered.value.expandKeys.forEach((k) => next.add(k));
+      return next;
+    });
+    function flatten(nodes, level, out) {
+      for (const node of nodes) {
+        const hasChildren = !!node.children?.length;
+        const expanded = hasChildren && effectiveExpanded.value.has(node.key);
+        out.push({ node, level, hasChildren, expanded });
+        if (hasChildren && expanded)
+          flatten(node.children ?? [], level + 1, out);
+      }
+    }
+    const flatItems = vue.computed(() => {
+      const out = [];
+      flatten(filtered.value.nodes, 0, out);
+      return out;
+    });
+    const empty = vue.computed(() => flatItems.value.length === 0);
+    function itemPadding(level) {
+      return `${level * (props.indent ?? 16)}px`;
+    }
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
+        empty.value ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_2, [
+          vue.renderSlot(_ctx.$slots, "empty", {}, () => [
+            _cache[1] || (_cache[1] = vue.createTextVNode(" No results ", -1))
+          ], true)
+        ])) : (vue.openBlock(), vue.createElementBlock("div", _hoisted_3, [
+          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(flatItems.value, (item) => {
+            return vue.openBlock(), vue.createElementBlock("div", {
+              key: item.node.key,
+              class: "tx-tree__item",
+              style: vue.normalizeStyle({ paddingLeft: itemPadding(item.level) }),
+              role: "treeitem",
+              "aria-expanded": item.hasChildren ? item.expanded : void 0,
+              "aria-selected": selectedSet.value.has(item.node.key),
+              onClick: ($event) => toggleSelect(item.node)
+            }, [
+              vue.renderSlot(_ctx.$slots, "item", {
+                node: item.node,
+                level: item.level,
+                expanded: item.expanded,
+                hasChildren: item.hasChildren,
+                selected: selectedSet.value.has(item.node.key),
+                toggleExpand: () => toggleExpand(item.node),
+                toggleSelect: () => toggleSelect(item.node),
+                indent: props.indent ?? 16
+              }, () => [
+                vue.createElementVNode("div", {
+                  class: vue.normalizeClass(["tx-tree__row", { "is-selected": selectedSet.value.has(item.node.key), "is-disabled": props.disabled || item.node.disabled }])
+                }, [
+                  item.hasChildren ? (vue.openBlock(), vue.createElementBlock("button", {
+                    key: 0,
+                    type: "button",
+                    class: "tx-tree__caret",
+                    "aria-label": item.expanded ? "Collapse" : "Expand",
+                    onClick: vue.withModifiers(($event) => toggleExpand(item.node), ["stop"])
+                  }, [
+                    (vue.openBlock(), vue.createElementBlock("svg", {
+                      viewBox: "0 0 24 24",
+                      width: "14",
+                      height: "14",
+                      style: vue.normalizeStyle({ transform: item.expanded ? "rotate(90deg)" : "rotate(0deg)" })
+                    }, [..._cache[2] || (_cache[2] = [
+                      vue.createElementVNode("path", {
+                        fill: "currentColor",
+                        d: "M10 6l6 6-6 6"
+                      }, null, -1)
+                    ])], 4))
+                  ], 8, _hoisted_5)) : (vue.openBlock(), vue.createElementBlock("span", _hoisted_6)),
+                  __props.checkable ? (vue.openBlock(), vue.createBlock(vue.unref(TxCheckbox.default), {
+                    key: 2,
+                    "model-value": selectedSet.value.has(item.node.key),
+                    disabled: props.disabled || item.node.disabled,
+                    "aria-label": "Select",
+                    onClick: _cache[0] || (_cache[0] = vue.withModifiers(() => {
+                    }, ["stop"])),
+                    "onUpdate:modelValue": () => toggleSelect(item.node)
+                  }, null, 8, ["model-value", "disabled", "onUpdate:modelValue"])) : vue.createCommentVNode("", true),
+                  item.node.icon ? (vue.openBlock(), vue.createBlock(vue.unref(index.TxIcon), {
+                    key: 3,
+                    icon: resolveIcon(item.node.icon),
+                    size: 16
+                  }, null, 8, ["icon"])) : vue.createCommentVNode("", true),
+                  vue.createElementVNode("span", _hoisted_7, vue.toDisplayString(item.node.label), 1)
+                ], 2)
+              ], true)
+            ], 12, _hoisted_4);
+          }), 128))
+        ]))
+      ]);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/dist/lib/tree-select/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 TxTreeSelect = require('./src/TxTreeSelect.vue.js');
+
+const TreeSelect = withInstall.withInstall(TxTreeSelect.default);
+
+exports.TxTreeSelect = TxTreeSelect.default;
+exports.TreeSelect = TreeSelect;
+exports.default = TreeSelect;

package/dist/lib/tree-select/src/TxTreeSelect.vue.js

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