@expcat/tigercat-vue 0.4.3 → 1.0.0

package/dist/chunk-OMYSFPX6.mjs

@@ -0,0 +1,173 @@
+import { defineComponent, ref, computed, h } from 'vue';
+import { navigateToFolder, filterHiddenFiles, filterFileItems, sortFileItems, classNames, getFileManagerContainerClasses, coerceClassValue, fileManagerBreadcrumbItemClasses, fileManagerBreadcrumbSeparatorClasses, fileManagerBreadcrumbClasses, fileManagerSearchClasses, fileManagerToolbarClasses, fileManagerContentClasses, fileManagerEmptyClasses, fileManagerLoadingClasses, getFileItemClasses, fileManagerItemNameClasses, fileManagerItemMetaClasses, formatFileSizeLabel, fileManagerItemIconClasses } from '@expcat/tigercat-core';
+
+// src/components/FileManager.ts
+var FileManager = defineComponent({
+  name: "TigerFileManager",
+  inheritAttrs: false,
+  props: {
+    files: { type: Array, default: () => [] },
+    viewMode: {
+      type: String,
+      default: "list"
+    },
+    selectedKeys: {
+      type: Array,
+      default: () => []
+    },
+    multiple: { type: Boolean, default: false },
+    sortField: {
+      type: String,
+      default: "name"
+    },
+    sortOrder: {
+      type: String,
+      default: "asc"
+    },
+    currentPath: {
+      type: Array,
+      default: () => []
+    },
+    showHidden: { type: Boolean, default: false },
+    draggable: { type: Boolean, default: false },
+    loading: { type: Boolean, default: false },
+    emptyText: { type: String, default: "Empty folder" },
+    searchable: { type: Boolean, default: false },
+    searchText: { type: String, default: "" },
+    className: { type: String, default: void 0 }
+  },
+  emits: [
+    "select",
+    "open",
+    "navigate",
+    "update:currentPath",
+    "update:searchText",
+    "update:selectedKeys"
+  ],
+  setup(props, { emit, attrs }) {
+    const localSearch = ref(props.searchText);
+    const currentItems = computed(() => navigateToFolder(props.files, props.currentPath));
+    const processedItems = computed(() => {
+      let items = filterHiddenFiles(currentItems.value, props.showHidden);
+      if (localSearch.value || props.searchText) {
+        items = filterFileItems(items, localSearch.value || props.searchText);
+      }
+      return sortFileItems(items, props.sortField, props.sortOrder);
+    });
+    const selectedSet = computed(() => new Set(props.selectedKeys));
+    const containerClasses = computed(
+      () => classNames(getFileManagerContainerClasses(props.className), coerceClassValue(attrs.class))
+    );
+    function handleSelect(item) {
+      if (item.disabled) return;
+      emit("select", item);
+      const keys = [...props.selectedKeys];
+      const idx = keys.indexOf(item.key);
+      if (idx >= 0) {
+        keys.splice(idx, 1);
+      } else {
+        if (!props.multiple) keys.length = 0;
+        keys.push(item.key);
+      }
+      emit("update:selectedKeys", keys);
+    }
+    function handleOpen(item) {
+      if (item.disabled) return;
+      if (item.type === "folder") {
+        const newPath = [...props.currentPath, item.name];
+        emit("update:currentPath", newPath);
+        emit("navigate", newPath);
+      } else {
+        emit("open", item);
+      }
+    }
+    function navigateToBreadcrumb(index) {
+      const newPath = props.currentPath.slice(0, index);
+      emit("update:currentPath", newPath);
+      emit("navigate", newPath);
+    }
+    return () => {
+      const breadcrumbItems = [
+        h(
+          "span",
+          {
+            class: fileManagerBreadcrumbItemClasses,
+            onClick: () => navigateToBreadcrumb(0)
+          },
+          "Root"
+        ),
+        ...props.currentPath.flatMap((seg, i) => [
+          h("span", { class: fileManagerBreadcrumbSeparatorClasses }, "/"),
+          h(
+            "span",
+            {
+              class: fileManagerBreadcrumbItemClasses,
+              onClick: () => navigateToBreadcrumb(i + 1)
+            },
+            seg
+          )
+        ])
+      ];
+      const breadcrumb = h(
+        "nav",
+        { class: fileManagerBreadcrumbClasses, "aria-label": "File path" },
+        breadcrumbItems
+      );
+      const searchInput = props.searchable ? h("input", {
+        type: "text",
+        class: fileManagerSearchClasses,
+        placeholder: "Search...",
+        value: localSearch.value,
+        onInput: (e) => {
+          const val = e.target.value;
+          localSearch.value = val;
+          emit("update:searchText", val);
+        }
+      }) : null;
+      const toolbar = h("div", { class: fileManagerToolbarClasses }, [
+        breadcrumb,
+        h("div", { class: "flex-1" }),
+        searchInput
+      ]);
+      const fileIcon = (item) => h(
+        "span",
+        { class: fileManagerItemIconClasses, "aria-hidden": "true" },
+        item.type === "folder" ? "\u{1F4C1}" : "\u{1F4C4}"
+      );
+      const renderItem = (item) => {
+        const isSelected = selectedSet.value.has(item.key);
+        const itemClass = getFileItemClasses(props.viewMode, isSelected);
+        const nameEl = h("span", { class: fileManagerItemNameClasses }, item.name);
+        const metaEls = props.viewMode === "list" ? [
+          item.size !== void 0 ? h("span", { class: fileManagerItemMetaClasses }, formatFileSizeLabel(item.size)) : null,
+          item.modified ? h("span", { class: fileManagerItemMetaClasses }, item.modified) : null
+        ] : [];
+        return h(
+          "div",
+          {
+            key: item.key,
+            class: itemClass,
+            role: "option",
+            "aria-selected": isSelected,
+            "data-disabled": item.disabled || void 0,
+            onClick: () => handleSelect(item),
+            onDblclick: () => handleOpen(item),
+            draggable: props.draggable && !item.disabled
+          },
+          [fileIcon(item), nameEl, ...metaEls]
+        );
+      };
+      const contentClass = props.viewMode === "grid" ? `${fileManagerContentClasses} grid grid-cols-4 gap-2` : fileManagerContentClasses;
+      const content = processedItems.value.length > 0 ? h(
+        "div",
+        { class: contentClass, role: "listbox", "aria-multiselectable": props.multiple },
+        processedItems.value.map(renderItem)
+      ) : h("div", { class: fileManagerEmptyClasses }, props.emptyText);
+      const loadingEl = props.loading ? h("div", { class: fileManagerLoadingClasses }, "Loading...") : null;
+      return h("div", { class: containerClasses.value }, [toolbar, content, loadingEl]);
+    };
+  }
+});
+var FileManager_default = FileManager;
+
+export { FileManager, FileManager_default };

package/dist/{chunk-W2OCMRRH.mjs → chunk-OXOCGMPN.mjs}

@@ -1,4 +1,4 @@
-import { createStatusIconWithLoading, createStatusIcon } from './chunk-7RRA3TIG.mjs';
+import { createStatusIconWithLoading, createStatusIcon } from './chunk-2TNZ4JNT.mjs';
 import { ref, defineComponent, computed, h, Teleport, TransitionGroup, createApp } from 'vue';
 import { classNames, messageContainerBaseClasses, messagePositionClasses, getMessageTypeClasses, defaultMessageThemeColors, messageBaseClasses, getMessageIconPath, messageIconClasses, messageLoadingSpinnerClasses, messageContentClasses, messageCloseButtonClasses, messageCloseIconPath, isBrowser, normalizeStringOption } from '@expcat/tigercat-core';
 

package/dist/{chunk-RVEEEDJQ.mjs → chunk-P4X7GS2X.mjs}

@@ -3,7 +3,7 @@ import { Link } from './chunk-4YHOD7LT.mjs';
 import { Loading } from './chunk-Q6OYCTQO.mjs';
 import { Tag } from './chunk-3G4VPV4D.mjs';
 import { Text } from './chunk-6V7XCCXN.mjs';
-import { Card } from './chunk-YXN3YY5Y.mjs';
+import { Card } from './chunk-KOTSKHPQ.mjs';
 import { Avatar } from './chunk-COCECPMG.mjs';
 import { defineComponent, computed, h } from 'vue';
 import { buildActivityGroups, classNames, coerceClassValue, mergeStyleValues, toActivityTimelineItems, formatActivityTime } from '@expcat/tigercat-core';

package/dist/{chunk-HNQZ5JRB.js → chunk-PBWSBNDS.js}

@@ -121,6 +121,28 @@ var Select = vue.defineComponent({
     noDataText: {
       type: String,
       default: "No options available"
+    },
+    /**
+     * Maximum number of tags in multi-select display
+     * @since 0.5.0
+     */
+    maxTagCount: {
+      type: Number,
+      default: void 0
+    },
+    /**
+     * Whether to use virtual scrolling
+     * @since 0.5.0
+     */
+    virtual: Boolean,
+    /**
+     * Height of the dropdown panel in pixels
+     * @default 256
+     * @since 0.5.0
+     */
+    listHeight: {
+      type: Number,
+      default: 256
     }
   },
   emits: ["update:modelValue", "change", "search"],
@@ -149,7 +171,12 @@ var Select = vue.defineComponent({
         }
         const currentValue = props.modelValue;
         const selectedOptions = allOptions.value.filter((opt) => currentValue.includes(opt.value));
-        return selectedOptions.map((opt) => opt.label).join(", ");
+        const labels = selectedOptions.map((opt) => opt.label);
+        if (props.maxTagCount !== void 0 && labels.length > props.maxTagCount) {
+          const visible = labels.slice(0, props.maxTagCount);
+          return `${visible.join(", ")} +${labels.length - props.maxTagCount}`;
+        }
+        return labels.join(", ");
       }
       const value = Array.isArray(props.modelValue) ? void 0 : props.modelValue;
       if (value === void 0 || value === null || value === "") {
@@ -456,7 +483,8 @@ var Select = vue.defineComponent({
             onKeydown: handleTriggerKeyDown,
             "aria-haspopup": "listbox",
             "aria-expanded": isOpen.value,
-            "aria-controls": listboxId
+            "aria-controls": listboxId,
+            "aria-activedescendant": isOpen.value && activeIndex.value >= 0 ? getOptionId(activeIndex.value) : void 0
           },
           [
             vue.h(
@@ -475,6 +503,7 @@ var Select = vue.defineComponent({
                 {
                   class: "inline-flex",
                   "data-tiger-select-clear": "",
+                  "aria-label": "Clear selection",
                   onClick: clearSelection
                 },
                 CloseIcon

package/dist/{chunk-6MJBCXPO.js → chunk-PUALBK3Y.js}

@@ -5,6 +5,8 @@ var chunkIVTBNUKQ_js = require('./chunk-IVTBNUKQ.js');
 var vue = require('vue');
 var tigercatCore = require('@expcat/tigercat-core');
 
+var dropdownIdCounter = 0;
+var createDropdownMenuId = () => `tiger-dropdown-menu-${++dropdownIdCounter}`;
 var DropdownContextKey = /* @__PURE__ */ Symbol("DropdownContext");
 var Dropdown = vue.defineComponent({
   name: "TigerDropdown",
@@ -43,17 +45,17 @@ var Dropdown = vue.defineComponent({
       default: false
     },
     /**
-     * Whether the dropdown is visible (controlled mode)
+     * Whether the dropdown is open (controlled mode)
      */
-    visible: {
+    open: {
       type: Boolean,
       default: void 0
     },
     /**
-     * Default visibility (uncontrolled mode)
+     * Default open state (uncontrolled mode)
      * @default false
      */
-    defaultVisible: {
+    defaultOpen: {
       type: Boolean,
       default: false
     },
@@ -85,26 +87,41 @@ var Dropdown = vue.defineComponent({
       default: void 0
     }
   },
-  emits: ["update:visible", "visible-change"],
+  emits: ["update:open", "open-change"],
   setup(props, { slots, emit, attrs }) {
     const attrsRecord = attrs;
     const attrsClass = attrsRecord.class;
     const attrsStyle = attrsRecord.style;
     vue.onMounted(() => tigercatCore.injectDropdownStyles());
-    const internalVisible = vue.ref(props.defaultVisible);
+    const menuId = createDropdownMenuId();
+    const previousActiveElement = vue.ref(null);
+    const internalVisible = vue.ref(props.defaultOpen);
     const currentVisible = vue.computed(
-      () => props.visible !== void 0 ? props.visible : internalVisible.value
+      () => props.open !== void 0 ? props.open : internalVisible.value
     );
     const containerRef = vue.ref(null);
     const triggerRef = vue.ref(null);
     const floatingRef = vue.ref(null);
     const setVisible = (visible) => {
       if (props.disabled && visible) return;
-      if (props.visible === void 0) {
+      if (visible && !currentVisible.value) {
+        previousActiveElement.value = tigercatCore.captureActiveElement();
+      }
+      if (props.open === void 0) {
         internalVisible.value = visible;
       }
-      emit("update:visible", visible);
-      emit("visible-change", visible);
+      emit("update:open", visible);
+      emit("open-change", visible);
+      if (visible) {
+        vue.nextTick(() => {
+          if (floatingRef.value) {
+            tigercatCore.focusFirstMenuItem(floatingRef.value);
+          }
+        });
+      } else {
+        tigercatCore.restoreFocus(previousActiveElement.value);
+        previousActiveElement.value = null;
+      }
     };
     const handleItemClick = () => {
       if (props.closeOnClick) setVisible(false);
@@ -124,6 +141,11 @@ var Dropdown = vue.defineComponent({
       if (props.trigger !== "click") return;
       setVisible(!currentVisible.value);
     };
+    const handleMenuKeyDown = (event) => {
+      if (floatingRef.value) {
+        tigercatCore.handleMenuNavigation(floatingRef.value, event);
+      }
+    };
     const {
       x,
       y,
@@ -229,7 +251,8 @@ var Dropdown = vue.defineComponent({
           onMouseenter: handleMouseEnter,
           onMouseleave: handleMouseLeave,
           "aria-haspopup": "menu",
-          "aria-expanded": currentVisible.value
+          "aria-expanded": currentVisible.value,
+          "aria-controls": currentVisible.value ? menuId : void 0
         },
         [triggerNode, chevronNode]
       ) : null;
@@ -241,9 +264,16 @@ var Dropdown = vue.defineComponent({
           style: menuWrapperStyles.value,
           onMouseenter: handleMouseEnter,
           onMouseleave: handleMouseLeave,
+          onKeydown: handleMenuKeyDown,
           hidden: !currentVisible.value
         },
-        menuNode
+        [
+          vue.h(
+            menuNode.type,
+            { ...menuNode.props || {}, id: menuId },
+            menuNode.children
+          )
+        ]
       ) : null;
       const {
         class: _class,

package/dist/chunk-PXRF4IJO.mjs

@@ -0,0 +1,159 @@
+import { defineComponent, computed, h, ref, Teleport } from 'vue';
+import { classNames, floatButtonBaseClasses, floatButtonShapeClasses, floatButtonSizeClasses, floatButtonTypeClasses, floatButtonDisabledClasses, coerceClassValue, mergeStyleValues, floatButtonGroupClasses } from '@expcat/tigercat-core';
+
+// src/components/FloatButton.ts
+var FloatButton = defineComponent({
+  name: "TigerFloatButton",
+  inheritAttrs: false,
+  props: {
+    shape: {
+      type: String,
+      default: "circle"
+    },
+    size: {
+      type: String,
+      default: "md"
+    },
+    type: {
+      type: String,
+      default: "primary"
+    },
+    tooltip: {
+      type: String,
+      default: void 0
+    },
+    disabled: {
+      type: Boolean,
+      default: false
+    },
+    ariaLabel: {
+      type: String,
+      default: void 0
+    },
+    className: {
+      type: String,
+      default: void 0
+    },
+    style: {
+      type: Object,
+      default: void 0
+    }
+  },
+  emits: ["click"],
+  setup(props, { slots, emit, attrs }) {
+    const classes = computed(
+      () => classNames(
+        floatButtonBaseClasses,
+        floatButtonShapeClasses[props.shape],
+        floatButtonSizeClasses[props.size],
+        floatButtonTypeClasses[props.type],
+        props.disabled && floatButtonDisabledClasses,
+        props.className,
+        coerceClassValue(attrs.class)
+      )
+    );
+    const handleClick = (e) => {
+      if (!props.disabled) {
+        emit("click", e);
+      }
+    };
+    return () => {
+      const attrsRecord = attrs;
+      const btn = h(
+        "button",
+        {
+          ...attrs,
+          class: classes.value,
+          style: mergeStyleValues(attrsRecord.style, props.style),
+          type: "button",
+          disabled: props.disabled,
+          "aria-label": props.ariaLabel ?? props.tooltip,
+          title: props.tooltip,
+          onClick: handleClick
+        },
+        slots.default?.()
+      );
+      return btn;
+    };
+  }
+});
+var FloatButtonGroup = defineComponent({
+  name: "TigerFloatButtonGroup",
+  inheritAttrs: false,
+  props: {
+    shape: {
+      type: String,
+      default: "circle"
+    },
+    trigger: {
+      type: String,
+      default: "click"
+    },
+    open: {
+      type: Boolean,
+      default: void 0
+    },
+    className: {
+      type: String,
+      default: void 0
+    },
+    style: {
+      type: Object,
+      default: void 0
+    }
+  },
+  emits: ["update:open"],
+  setup(props, { slots, emit, attrs }) {
+    const internalOpen = ref(false);
+    const isOpen = computed(() => props.open ?? internalOpen.value);
+    const toggle = () => {
+      const next = !isOpen.value;
+      internalOpen.value = next;
+      emit("update:open", next);
+    };
+    const groupClasses = computed(
+      () => classNames(
+        floatButtonGroupClasses,
+        props.className,
+        coerceClassValue(attrs.class)
+      )
+    );
+    return () => {
+      const attrsRecord = attrs;
+      const children = [];
+      if (slots.trigger) {
+        children.push(
+          h("div", { onClick: props.trigger === "click" ? toggle : void 0 }, slots.trigger())
+        );
+      }
+      if (isOpen.value && slots.default) {
+        const defaultSlot = slots.default();
+        for (const node of defaultSlot) {
+          children.push(node);
+        }
+      }
+      return h(Teleport, { to: "body" }, [
+        h(
+          "div",
+          {
+            ...attrs,
+            class: groupClasses.value,
+            style: mergeStyleValues(attrsRecord.style, props.style),
+            onMouseenter: props.trigger === "hover" ? () => {
+              internalOpen.value = true;
+              emit("update:open", true);
+            } : void 0,
+            onMouseleave: props.trigger === "hover" ? () => {
+              internalOpen.value = false;
+              emit("update:open", false);
+            } : void 0
+          },
+          children
+        )
+      ]);
+    };
+  }
+});
+var FloatButton_default = FloatButton;
+
+export { FloatButton, FloatButtonGroup, FloatButton_default };

package/dist/chunk-Q57TYGO4.js

@@ -0,0 +1,123 @@
+'use strict';
+
+var vue = require('vue');
+var tigercatCore = require('@expcat/tigercat-core');
+
+// src/components/Mentions.ts
+var Mentions = vue.defineComponent({
+  name: "TigerMentions",
+  props: {
+    modelValue: { type: String, default: "" },
+    prefix: { type: String, default: "@" },
+    options: { type: Array, default: () => [] },
+    placeholder: { type: String, default: void 0 },
+    disabled: { type: Boolean, default: false },
+    size: { type: String, default: "md" },
+    rows: { type: Number, default: 3 }
+  },
+  emits: ["update:modelValue", "change", "select"],
+  setup(props, { emit, attrs }) {
+    const isOpen = vue.ref(false);
+    const activeIndex = vue.ref(0);
+    const mentionStartPos = vue.ref(-1);
+    const query = vue.ref("");
+    const textareaRef = vue.ref(null);
+    const containerRef = vue.ref(null);
+    const filteredOptions = vue.computed(() => {
+      if (!query.value) return props.options || [];
+      const q = query.value.toLowerCase();
+      return (props.options || []).filter((o) => !o.disabled && o.label.toLowerCase().includes(q));
+    });
+    function handleInput(e) {
+      const target = e.target;
+      const value = target.value;
+      emit("update:modelValue", value);
+      emit("change", value);
+      const cursorPos = target.selectionStart ?? value.length;
+      const result = tigercatCore.extractMentionQuery(value, cursorPos, props.prefix);
+      if (result && filteredOptions.value.length > 0) {
+        query.value = result.query;
+        mentionStartPos.value = result.startPos;
+        isOpen.value = true;
+        activeIndex.value = 0;
+      } else {
+        isOpen.value = false;
+      }
+    }
+    function selectOption(option) {
+      if (option.disabled) return;
+      const val = props.modelValue || "";
+      const before = val.slice(0, mentionStartPos.value);
+      const after = val.slice(textareaRef.value?.selectionStart ?? val.length);
+      const newValue = `${before}${props.prefix}${option.value} ${after}`;
+      emit("update:modelValue", newValue);
+      emit("change", newValue);
+      emit("select", option);
+      isOpen.value = false;
+    }
+    function handleKeydown(e) {
+      if (!isOpen.value) return;
+      if (e.key === "ArrowDown") {
+        e.preventDefault();
+        activeIndex.value = (activeIndex.value + 1) % filteredOptions.value.length;
+      } else if (e.key === "ArrowUp") {
+        e.preventDefault();
+        activeIndex.value = (activeIndex.value - 1 + filteredOptions.value.length) % filteredOptions.value.length;
+      } else if (e.key === "Enter") {
+        e.preventDefault();
+        const opt = filteredOptions.value[activeIndex.value];
+        if (opt) selectOption(opt);
+      } else if (e.key === "Escape") {
+        isOpen.value = false;
+      }
+    }
+    function onClickOutside(e) {
+      if (containerRef.value && !containerRef.value.contains(e.target)) {
+        isOpen.value = false;
+      }
+    }
+    vue.watch(isOpen, (val) => {
+      if (val) document.addEventListener("mousedown", onClickOutside);
+      else document.removeEventListener("mousedown", onClickOutside);
+    });
+    vue.onBeforeUnmount(() => {
+      document.removeEventListener("mousedown", onClickOutside);
+    });
+    return () => {
+      const wrapperClass = tigercatCore.classNames("relative", tigercatCore.coerceClassValue(attrs.class));
+      return vue.h("div", { ref: containerRef, class: wrapperClass }, [
+        vue.h("textarea", {
+          ref: textareaRef,
+          value: props.modelValue,
+          class: tigercatCore.getMentionsInputClasses(props.size, props.disabled),
+          placeholder: props.placeholder,
+          disabled: props.disabled,
+          rows: props.rows,
+          onInput: handleInput,
+          onKeydown: handleKeydown
+        }),
+        isOpen.value && filteredOptions.value.length > 0 ? vue.h(
+          "div",
+          { class: tigercatCore.mentionsDropdownClasses, role: "listbox" },
+          filteredOptions.value.map(
+            (opt, i) => vue.h(
+              "div",
+              {
+                key: opt.value,
+                class: tigercatCore.getMentionsOptionClasses(i === activeIndex.value, !!opt.disabled),
+                role: "option",
+                "aria-selected": i === activeIndex.value,
+                onClick: () => selectOption(opt)
+              },
+              opt.label
+            )
+          )
+        ) : null
+      ]);
+    };
+  }
+});
+var Mentions_default = Mentions;
+
+exports.Mentions = Mentions;
+exports.Mentions_default = Mentions_default;

package/dist/{chunk-TQOMX62N.js → chunk-Q6CGPWQF.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkBFNHRBWN_js = require('./chunk-BFNHRBWN.js');
+var chunk2WZGK7XJ_js = require('./chunk-2WZGK7XJ.js');
 var vue = require('vue');
 var tigercatCore = require('@expcat/tigercat-core');
 
@@ -9,10 +9,10 @@ var Tooltip = vue.defineComponent({
   name: "TigerTooltip",
   inheritAttrs: false,
   props: {
-    /** Whether the tooltip is visible (controlled mode) */
-    visible: { type: Boolean, default: void 0 },
-    /** Default visibility (uncontrolled mode) @default false */
-    defaultVisible: { type: Boolean, default: false },
+    /** Whether the tooltip is open (controlled mode) */
+    open: { type: Boolean, default: void 0 },
+    /** Default open state (uncontrolled mode) @default false */
+    defaultOpen: { type: Boolean, default: false },
     /** Tooltip content text */
     content: { type: String, default: void 0 },
     /** Trigger type @default 'hover' */
@@ -27,7 +27,7 @@ var Tooltip = vue.defineComponent({
     className: { type: String, default: void 0 },
     style: { type: [String, Object, Array], default: void 0 }
   },
-  emits: ["update:visible", "visible-change"],
+  emits: ["update:open", "open-change"],
   setup(props, { slots, emit, attrs }) {
     const attrsRecord = attrs;
     const {
@@ -37,7 +37,7 @@ var Tooltip = vue.defineComponent({
       floatingRef,
       floatingStyles,
       triggerHandlers
-    } = chunkBFNHRBWN_js.useFloatingPopup({ props, emit });
+    } = chunk2WZGK7XJ_js.useFloatingPopup({ props, emit });
     const tooltipId = createTooltipId();
     const containerClasses = vue.computed(
       () => tigercatCore.classNames(tigercatCore.getTooltipContainerClasses(), props.className, tigercatCore.coerceClassValue(attrsRecord.class))