@talex-touch/tuffex 0.3.3

package/dist/lib/card-item/src/TxCardItem.vue2.js

@@ -0,0 +1,131 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+
+const _hoisted_1 = ["role", "tabindex"];
+const _hoisted_2 = {
+  key: 0,
+  class: "tx-card-item__avatar",
+  "aria-hidden": "true"
+};
+const _hoisted_3 = ["src"];
+const _hoisted_4 = {
+  key: 1,
+  class: "tx-card-item__avatar tx-card-item__avatar--icon",
+  "aria-hidden": "true"
+};
+const _hoisted_5 = {
+  key: 2,
+  class: "tx-card-item__avatar tx-card-item__avatar--text",
+  "aria-hidden": "true"
+};
+const _hoisted_6 = { class: "tx-card-item__main" };
+const _hoisted_7 = { class: "tx-card-item__top" };
+const _hoisted_8 = { class: "tx-card-item__title-area" };
+const _hoisted_9 = { class: "tx-card-item__title" };
+const _hoisted_10 = {
+  key: 0,
+  class: "tx-card-item__subtitle"
+};
+const _hoisted_11 = {
+  key: 0,
+  class: "tx-card-item__right"
+};
+const _hoisted_12 = {
+  key: 0,
+  class: "tx-card-item__desc"
+};
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{
+    name: "TxCardItem"
+  },
+  __name: "TxCardItem",
+  props: {
+    role: { default: "button" },
+    title: { default: "" },
+    subtitle: { default: "" },
+    description: { default: "" },
+    iconClass: { default: "" },
+    avatarText: { default: "" },
+    avatarUrl: { default: "" },
+    avatarSize: { default: 36 },
+    avatarShape: { default: "circle" },
+    clickable: { type: Boolean, default: false },
+    active: { type: Boolean, default: false },
+    disabled: { type: Boolean, default: false }
+  },
+  emits: ["click"],
+  setup(__props) {
+    const props = __props;
+    const avatarStyle = vue.computed(() => {
+      const size = `${props.avatarSize}px`;
+      const radius = props.avatarShape === "circle" ? "999px" : "12px";
+      return {
+        "--tx-card-item-avatar-size": size,
+        "--tx-card-item-avatar-radius": radius
+      };
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: vue.normalizeClass(["tx-card-item", {
+          "tx-card-item--clickable": __props.clickable,
+          "tx-card-item--active": __props.active,
+          "tx-card-item--disabled": __props.disabled,
+          "tx-card-item--no-left": !(_ctx.$slots.avatar || __props.avatarUrl || __props.iconClass || __props.avatarText)
+        }]),
+        role: __props.role,
+        tabindex: __props.clickable && !__props.disabled ? 0 : -1,
+        onClick: _cache[0] || (_cache[0] = ($event) => !__props.disabled && __props.clickable && _ctx.$emit("click", $event)),
+        onKeydown: _cache[1] || (_cache[1] = vue.withKeys(($event) => !__props.disabled && __props.clickable && _ctx.$emit("click", $event), ["enter"]))
+      }, [
+        _ctx.$slots.avatar || __props.avatarUrl || __props.iconClass || __props.avatarText ? (vue.openBlock(), vue.createElementBlock("div", {
+          key: 0,
+          class: "tx-card-item__left",
+          style: vue.normalizeStyle(avatarStyle.value)
+        }, [
+          vue.renderSlot(_ctx.$slots, "avatar", {}, () => [
+            __props.avatarUrl ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_2, [
+              vue.createElementVNode("img", {
+                class: "tx-card-item__avatar-img",
+                src: __props.avatarUrl,
+                alt: ""
+              }, null, 8, _hoisted_3)
+            ])) : __props.iconClass ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_4, [
+              vue.createElementVNode("i", {
+                class: vue.normalizeClass(__props.iconClass)
+              }, null, 2)
+            ])) : (vue.openBlock(), vue.createElementBlock("div", _hoisted_5, vue.toDisplayString(__props.avatarText), 1))
+          ], true)
+        ], 4)) : vue.createCommentVNode("", true),
+        vue.createElementVNode("div", _hoisted_6, [
+          vue.createElementVNode("div", _hoisted_7, [
+            vue.createElementVNode("div", _hoisted_8, [
+              vue.createElementVNode("div", _hoisted_9, [
+                vue.renderSlot(_ctx.$slots, "title", {}, () => [
+                  vue.createTextVNode(vue.toDisplayString(__props.title), 1)
+                ], true)
+              ]),
+              __props.subtitle || _ctx.$slots.subtitle ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_10, [
+                vue.renderSlot(_ctx.$slots, "subtitle", {}, () => [
+                  vue.createTextVNode(vue.toDisplayString(__props.subtitle), 1)
+                ], true)
+              ])) : vue.createCommentVNode("", true)
+            ]),
+            _ctx.$slots.right ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_11, [
+              vue.renderSlot(_ctx.$slots, "right", {}, void 0, true)
+            ])) : vue.createCommentVNode("", true)
+          ]),
+          __props.description || _ctx.$slots.description ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_12, [
+            vue.renderSlot(_ctx.$slots, "description", {}, () => [
+              vue.createTextVNode(vue.toDisplayString(__props.description), 1)
+            ], true)
+          ])) : vue.createCommentVNode("", true)
+        ])
+      ], 42, _hoisted_1);
+    };
+  }
+});
+
+exports.default = _sfc_main;

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

package/dist/lib/cascader/src/TxCascader.vue.js

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

package/dist/lib/cascader/src/TxCascader.vue2.js

@@ -0,0 +1,524 @@
+'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 TxCheckbox = require('../../checkbox/src/TxCheckbox.vue.js');
+const TxPopover = require('../../popover/src/TxPopover.vue.js');
+const TxSearchInput = require('../../search-input/src/TxSearchInput.vue.js');
+const TxTag_vue_vue_type_script_setup_true_lang = require('../../tag/src/TxTag.vue.js');
+;/* empty css                        */
+
+const _hoisted_1 = ["tabindex", "aria-expanded"];
+const _hoisted_2 = { class: "tx-cascader__value" };
+const _hoisted_3 = {
+  key: 0,
+  class: "tx-cascader__tags"
+};
+const _hoisted_4 = {
+  key: 1,
+  class: "tx-cascader__placeholder"
+};
+const _hoisted_5 = {
+  key: 0,
+  class: "tx-cascader__text"
+};
+const _hoisted_6 = {
+  key: 1,
+  class: "tx-cascader__placeholder"
+};
+const _hoisted_7 = {
+  key: 0,
+  class: "tx-cascader__search"
+};
+const _hoisted_8 = {
+  key: 1,
+  class: "tx-cascader__search-list"
+};
+const _hoisted_9 = { class: "tx-cascader__search-label" };
+const _hoisted_10 = {
+  key: 0,
+  class: "tx-cascader__empty"
+};
+const _hoisted_11 = {
+  key: 2,
+  class: "tx-cascader__columns"
+};
+const _hoisted_12 = { class: "tx-cascader__label" };
+const _hoisted_13 = {
+  key: 0,
+  class: "tx-cascader__meta"
+};
+const _hoisted_14 = {
+  key: 1,
+  class: "tx-cascader__meta"
+};
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{ name: "TxCascader" },
+  __name: "TxCascader",
+  props: {
+    modelValue: {},
+    options: { default: () => [] },
+    multiple: { type: Boolean, default: false },
+    disabled: { type: Boolean, default: false },
+    placeholder: { default: "请选择" },
+    searchable: { type: Boolean, default: true },
+    remote: { type: Boolean },
+    searchLoading: { type: Boolean },
+    searchResults: {},
+    searchDebounce: {},
+    clearable: { type: Boolean, default: true },
+    placement: { default: "bottom-start" },
+    dropdownOffset: { default: 6 },
+    dropdownWidth: { default: 360 },
+    dropdownMaxWidth: { default: 520 },
+    dropdownMaxHeight: { default: 340 },
+    expandTrigger: { default: "both" },
+    load: { type: Function, default: void 0 },
+    resolvePath: {}
+  },
+  emits: ["update:modelValue", "change", "open", "close", "search"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const open = vue.ref(false);
+    const triggerRef = vue.ref(null);
+    const query = vue.ref("");
+    const activePath = vue.ref([]);
+    const loadedChildren = vue.ref(/* @__PURE__ */ new Map());
+    const loadingKeys = vue.ref(/* @__PURE__ */ new Set());
+    function pathKey(path) {
+      return path.join("::");
+    }
+    function getChildren(node, path) {
+      if (!node)
+        return props.options;
+      if (Array.isArray(node.children) && node.children.length)
+        return node.children;
+      const k = pathKey(path);
+      return loadedChildren.value.get(k) ?? [];
+    }
+    function isLeaf(node, path) {
+      if (node.leaf)
+        return true;
+      const children = getChildren(node, path);
+      if (children.length)
+        return false;
+      return !props.load;
+    }
+    async function ensureChildren(node, path, level) {
+      if (!props.load)
+        return;
+      if (!node)
+        return;
+      if (node.leaf)
+        return;
+      const direct = node.children;
+      if (Array.isArray(direct) && direct.length)
+        return;
+      const k = pathKey(path);
+      if (loadedChildren.value.has(k))
+        return;
+      if (loadingKeys.value.has(k))
+        return;
+      loadingKeys.value.add(k);
+      try {
+        const children = await props.load(node, level);
+        loadedChildren.value.set(k, children);
+      } finally {
+        loadingKeys.value.delete(k);
+      }
+    }
+    const selectedPaths = vue.computed(() => {
+      const v = props.modelValue;
+      if (props.multiple)
+        return Array.isArray(v) ? v : [];
+      return Array.isArray(v) ? [v] : [];
+    });
+    function samePath(a, b) {
+      if (a.length !== b.length)
+        return false;
+      for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i])
+          return false;
+      }
+      return true;
+    }
+    function setValue(v) {
+      emit("update:modelValue", v);
+      emit("change", v);
+    }
+    function toggleSelect(path) {
+      if (props.disabled)
+        return;
+      if (props.multiple) {
+        const next = selectedPaths.value.slice();
+        const idx = next.findIndex((p) => samePath(p, path));
+        if (idx >= 0)
+          next.splice(idx, 1);
+        else next.push(path);
+        setValue(next);
+        return;
+      }
+      setValue(path);
+      open.value = false;
+    }
+    function clear() {
+      if (props.disabled)
+        return;
+      setValue(props.multiple ? [] : void 0);
+    }
+    function onClearClick() {
+      clear();
+      open.value = false;
+    }
+    function findNodeByPath(path) {
+      let current = null;
+      let list = props.options;
+      for (let i = 0; i < path.length; i++) {
+        const v = path[i];
+        const n = list.find((x) => x.value === v) ?? null;
+        if (!n)
+          return null;
+        current = n;
+        list = getChildren(n, path.slice(0, i + 1));
+      }
+      return current;
+    }
+    function formatPath(path) {
+      const labels = [];
+      let list = props.options;
+      for (let i = 0; i < path.length; i++) {
+        const v = path[i];
+        const n = list.find((x) => x.value === v);
+        if (!n)
+          break;
+        labels.push(n.label);
+        list = getChildren(n, path.slice(0, i + 1));
+      }
+      return labels.join(" / ");
+    }
+    const displayText = vue.computed(() => {
+      if (props.multiple)
+        return "";
+      const v = props.modelValue;
+      const path = Array.isArray(v) ? v : null;
+      if (!path || !path.length)
+        return "";
+      return formatPath(path);
+    });
+    const displayTags = vue.computed(() => {
+      if (!props.multiple)
+        return [];
+      return selectedPaths.value.map((p) => ({ key: pathKey(p), label: formatPath(p) }));
+    });
+    const columns = vue.computed(() => {
+      const out = [];
+      let list = props.options;
+      let current = null;
+      for (let level = 0; level <= activePath.value.length; level++) {
+        const column = list.map((n) => {
+          const p2 = [...activePath.value.slice(0, level), n.value];
+          const k = pathKey(p2);
+          return {
+            node: n,
+            level,
+            path: p2,
+            leaf: isLeaf(n, p2),
+            loading: loadingKeys.value.has(k)
+          };
+        });
+        out.push(column);
+        const nextVal = activePath.value[level];
+        if (nextVal === void 0)
+          break;
+        current = list.find((x) => x.value === nextVal) ?? null;
+        if (!current)
+          break;
+        const p = activePath.value.slice(0, level + 1);
+        list = getChildren(current, p);
+        if (!list.length)
+          break;
+      }
+      return out;
+    });
+    async function onHoverItem(item) {
+      if (props.expandTrigger === "click")
+        return;
+      if (props.disabled || item.node.disabled)
+        return;
+      if (item.leaf)
+        return;
+      activePath.value = item.path;
+      if (!props.load)
+        return;
+      if (item.leaf)
+        return;
+      await ensureChildren(item.node, item.path, item.level + 1);
+    }
+    async function onPick(item) {
+      if (props.disabled || item.node.disabled)
+        return;
+      if (item.leaf) {
+        toggleSelect(item.path);
+        return;
+      }
+      if (props.expandTrigger === "hover") {
+        return;
+      }
+      activePath.value = item.path;
+      await ensureChildren(item.node, item.path, item.level + 1);
+    }
+    function walkPaths(list, prefix, out) {
+      for (const n of list) {
+        const p = [...prefix, n.value];
+        const k = pathKey(p);
+        const kids = getChildren(n, p);
+        const leaf = isLeaf(n, p);
+        if (leaf) {
+          out.push({
+            key: k,
+            path: p,
+            label: formatPath(p),
+            disabled: !!n.disabled,
+            checked: selectedPaths.value.some((x) => samePath(x, p))
+          });
+        }
+        if (kids.length) {
+          walkPaths(kids, p, out);
+        }
+      }
+    }
+    const searchHits = vue.computed(() => {
+      const q = query.value.trim().toLowerCase();
+      if (!q)
+        return [];
+      const all = [];
+      walkPaths(props.options, [], all);
+      return all.filter((h) => h.label.toLowerCase().includes(q));
+    });
+    vue.watch(
+      open,
+      async (v) => {
+        if (v)
+          emit("open");
+        else
+          emit("close");
+        if (!v) {
+          query.value = "";
+          return;
+        }
+        await vue.nextTick();
+        if (props.load && activePath.value.length) {
+          const node = findNodeByPath(activePath.value);
+          if (node)
+            await ensureChildren(node, activePath.value, activePath.value.length);
+        }
+      },
+      { flush: "post" }
+    );
+    vue.watch(
+      () => props.modelValue,
+      (v) => {
+        if (props.multiple)
+          return;
+        const path = Array.isArray(v) ? v : [];
+        if (path.length)
+          activePath.value = path;
+      },
+      { immediate: true }
+    );
+    function onTriggerKeydown(e) {
+      if (props.disabled)
+        return;
+      if (e.key === "Enter" || e.key === " ") {
+        e.preventDefault();
+        open.value = !open.value;
+      }
+      if (e.key === "Escape") {
+        open.value = false;
+      }
+    }
+    __expose({
+      open: () => open.value = true,
+      close: () => open.value = false,
+      toggle: () => open.value = !open.value,
+      focus: () => triggerRef.value?.focus?.(),
+      blur: () => triggerRef.value?.blur?.(),
+      clear,
+      setValue,
+      getValue: () => props.modelValue
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(TxPopover.default, {
+        modelValue: open.value,
+        "onUpdate:modelValue": _cache[3] || (_cache[3] = ($event) => open.value = $event),
+        disabled: __props.disabled,
+        placement: __props.placement,
+        offset: __props.dropdownOffset,
+        width: __props.dropdownWidth,
+        "max-width": __props.dropdownMaxWidth,
+        "reference-full-width": true
+      }, {
+        reference: vue.withCtx(() => [
+          vue.createElementVNode("div", {
+            ref_key: "triggerRef",
+            ref: triggerRef,
+            class: vue.normalizeClass(["tx-cascader", { "is-open": open.value, "is-disabled": __props.disabled }]),
+            tabindex: __props.disabled ? -1 : 0,
+            role: "combobox",
+            "aria-haspopup": "listbox",
+            "aria-expanded": open.value,
+            onKeydown: onTriggerKeydown
+          }, [
+            vue.createElementVNode("div", _hoisted_2, [
+              __props.multiple ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
+                displayTags.value.length ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_3, [
+                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(displayTags.value, (t) => {
+                    return vue.openBlock(), vue.createBlock(TxTag_vue_vue_type_script_setup_true_lang.default, {
+                      key: t.key,
+                      label: t.label
+                    }, null, 8, ["label"]);
+                  }), 128))
+                ])) : (vue.openBlock(), vue.createElementBlock("span", _hoisted_4, vue.toDisplayString(__props.placeholder), 1))
+              ], 64)) : (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
+                displayText.value ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_5, vue.toDisplayString(displayText.value), 1)) : (vue.openBlock(), vue.createElementBlock("span", _hoisted_6, vue.toDisplayString(__props.placeholder), 1))
+              ], 64))
+            ]),
+            __props.clearable && !__props.disabled && selectedPaths.value.length ? (vue.openBlock(), vue.createElementBlock("button", {
+              key: 0,
+              type: "button",
+              class: "tx-cascader__clear",
+              "aria-label": "Clear",
+              onClick: vue.withModifiers(onClearClick, ["stop"])
+            }, [..._cache[4] || (_cache[4] = [
+              vue.createElementVNode("svg", {
+                viewBox: "0 0 24 24",
+                width: "14",
+                height: "14"
+              }, [
+                vue.createElementVNode("path", {
+                  fill: "currentColor",
+                  d: "M12 10.586l4.95-4.95 1.414 1.414-4.95 4.95 4.95 4.95-1.414 1.414-4.95-4.95-4.95 4.95-1.414-1.414 4.95-4.95-4.95-4.95 1.414-1.414z"
+                })
+              ], -1)
+            ])])) : vue.createCommentVNode("", true),
+            _cache[5] || (_cache[5] = vue.createElementVNode("span", {
+              class: "tx-cascader__arrow",
+              "aria-hidden": "true"
+            }, [
+              vue.createElementVNode("svg", {
+                viewBox: "0 0 24 24",
+                width: "16",
+                height: "16"
+              }, [
+                vue.createElementVNode("path", {
+                  fill: "currentColor",
+                  d: "M12 15.0006L7.75732 10.758L9.17154 9.34375L12 12.1722L14.8284 9.34375L16.2426 10.758L12 15.0006Z"
+                })
+              ])
+            ], -1))
+          ], 42, _hoisted_1)
+        ]),
+        default: vue.withCtx(() => [
+          vue.createElementVNode("div", {
+            class: "tx-cascader__panel",
+            role: "listbox",
+            style: vue.normalizeStyle({ maxHeight: `${__props.dropdownMaxHeight}px` })
+          }, [
+            __props.searchable ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_7, [
+              vue.createVNode(TxSearchInput.default, {
+                modelValue: query.value,
+                "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => query.value = $event),
+                placeholder: "Search"
+              }, null, 8, ["modelValue"])
+            ])) : vue.createCommentVNode("", true),
+            query.value.trim() ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_8, [
+              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(searchHits.value, (hit) => {
+                return vue.openBlock(), vue.createBlock(TxCardItem.default, {
+                  key: hit.key,
+                  class: vue.normalizeClass(["tx-cascader__search-item", { "is-disabled": hit.disabled }]),
+                  clickable: !hit.disabled,
+                  active: hit.checked,
+                  disabled: hit.disabled,
+                  onClick: ($event) => toggleSelect(hit.path)
+                }, vue.createSlots({
+                  title: vue.withCtx(() => [
+                    vue.createElementVNode("span", _hoisted_9, vue.toDisplayString(hit.label), 1)
+                  ]),
+                  _: 2
+                }, [
+                  __props.multiple ? {
+                    name: "avatar",
+                    fn: vue.withCtx(() => [
+                      vue.createVNode(TxCheckbox.default, {
+                        "model-value": hit.checked,
+                        disabled: hit.disabled,
+                        "aria-label": "Select",
+                        onClick: _cache[1] || (_cache[1] = vue.withModifiers(() => {
+                        }, ["stop"])),
+                        "onUpdate:modelValue": () => toggleSelect(hit.path)
+                      }, null, 8, ["model-value", "disabled", "onUpdate:modelValue"])
+                    ]),
+                    key: "0"
+                  } : void 0
+                ]), 1032, ["class", "clickable", "active", "disabled", "onClick"]);
+              }), 128)),
+              !searchHits.value.length ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_10, " No results ")) : vue.createCommentVNode("", true)
+            ])) : (vue.openBlock(), vue.createElementBlock("div", _hoisted_11, [
+              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(columns.value, (col, idx) => {
+                return vue.openBlock(), vue.createElementBlock("div", {
+                  key: idx,
+                  class: "tx-cascader__col"
+                }, [
+                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(col, (item) => {
+                    return vue.openBlock(), vue.createBlock(TxCardItem.default, {
+                      key: pathKey(item.path),
+                      class: vue.normalizeClass(["tx-cascader__item", {
+                        "is-disabled": item.node.disabled,
+                        "is-active": activePath.value[item.level] === item.node.value,
+                        "is-checked": selectedPaths.value.some((p) => samePath(p, item.path))
+                      }]),
+                      clickable: !item.node.disabled,
+                      disabled: !!item.node.disabled,
+                      active: activePath.value[item.level] === item.node.value || selectedPaths.value.some((p) => samePath(p, item.path)),
+                      onMouseenter: ($event) => onHoverItem(item),
+                      onClick: ($event) => onPick(item)
+                    }, vue.createSlots({
+                      title: vue.withCtx(() => [
+                        vue.createElementVNode("span", _hoisted_12, vue.toDisplayString(item.node.label), 1)
+                      ]),
+                      right: vue.withCtx(() => [
+                        item.loading ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_13, "Loading")) : !item.leaf ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_14, "›")) : vue.createCommentVNode("", true)
+                      ]),
+                      _: 2
+                    }, [
+                      __props.multiple && item.leaf ? {
+                        name: "avatar",
+                        fn: vue.withCtx(() => [
+                          vue.createVNode(TxCheckbox.default, {
+                            "model-value": selectedPaths.value.some((p) => samePath(p, item.path)),
+                            disabled: !!item.node.disabled,
+                            "aria-label": "Select",
+                            onClick: _cache[2] || (_cache[2] = vue.withModifiers(() => {
+                            }, ["stop"])),
+                            "onUpdate:modelValue": () => toggleSelect(item.path)
+                          }, null, 8, ["model-value", "disabled", "onUpdate:modelValue"])
+                        ]),
+                        key: "0"
+                      } : void 0
+                    ]), 1032, ["class", "clickable", "disabled", "active", "onMouseenter", "onClick"]);
+                  }), 128))
+                ]);
+              }), 128))
+            ]))
+          ], 4)
+        ]),
+        _: 1
+      }, 8, ["modelValue", "disabled", "placement", "offset", "width", "max-width"]);
+    };
+  }
+});
+
+exports.default = _sfc_main;