@expcat/tigercat-vue 1.1.0 → 1.2.0

package/dist/chunk-OXIODAJS.js

@@ -0,0 +1,192 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/components/ScrollSpy.ts
+
+
+
+
+
+
+
+
+
+var _vue = require('vue');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _tigercatcore = require('@expcat/tigercat-core');
+var getWindowContainer = () => window;
+var ScrollSpy = _vue.defineComponent.call(void 0, {
+  name: "TigerScrollSpy",
+  inheritAttrs: false,
+  props: {
+    items: {
+      type: Array,
+      default: () => []
+    },
+    activeKey: {
+      type: [String, Number],
+      default: void 0
+    },
+    defaultActiveKey: {
+      type: [String, Number],
+      default: void 0
+    },
+    offsetTop: {
+      type: Number,
+      default: 0
+    },
+    targetOffset: {
+      type: Number,
+      default: void 0
+    },
+    bounds: {
+      type: Number,
+      default: 5
+    },
+    direction: {
+      type: String,
+      default: "vertical"
+    },
+    sticky: {
+      type: Boolean,
+      default: false
+    },
+    ariaLabel: {
+      type: String,
+      default: "Scroll navigation"
+    },
+    getContainer: {
+      type: Function,
+      default: getWindowContainer
+    },
+    className: {
+      type: String,
+      default: void 0
+    },
+    style: {
+      type: Object,
+      default: void 0
+    }
+  },
+  emits: ["update:activeKey", "change", "click"],
+  setup(props, { attrs, emit }) {
+    const innerActiveKey = _vue.ref.call(void 0, 
+      _tigercatcore.getInitialScrollSpyActiveKey.call(void 0, props.items, props.activeKey, props.defaultActiveKey)
+    );
+    const isControlled = _vue.computed.call(void 0, () => props.activeKey !== void 0);
+    const currentActiveKey = _vue.computed.call(void 0, 
+      () => isControlled.value ? props.activeKey : innerActiveKey.value
+    );
+    const activeKeyString = _vue.computed.call(void 0, 
+      () => currentActiveKey.value === void 0 ? "" : _tigercatcore.getScrollSpyKeyString.call(void 0, currentActiveKey.value)
+    );
+    const flatItems = _vue.computed.call(void 0, () => _tigercatcore.flattenScrollSpyItems.call(void 0, props.items));
+    let stopObserver = null;
+    const emitActive = (item, source) => {
+      const nextKeyString = _tigercatcore.getScrollSpyKeyString.call(void 0, item.key);
+      if (nextKeyString === activeKeyString.value) return;
+      const payload = _tigercatcore.createScrollSpyPayload.call(void 0, item, source);
+      if (!isControlled.value) innerActiveKey.value = item.key;
+      emit("update:activeKey", item.key);
+      emit("change", item.key, item, payload);
+    };
+    const setupObserver = () => {
+      _optionalChain([stopObserver, 'optionalCall', _ => _()]);
+      stopObserver = _tigercatcore.createScrollSpyObserver.call(void 0, props.items, {
+        container: props.getContainer(),
+        offsetTop: props.offsetTop,
+        targetOffset: props.targetOffset,
+        bounds: props.bounds,
+        onChange: (item) => emitActive(item, "scroll")
+      });
+    };
+    const handleClick = (item, event) => {
+      event.preventDefault();
+      if (item.disabled) return;
+      emit("click", item, event);
+      emitActive(item, "click");
+      _tigercatcore.scrollToScrollSpyItem.call(void 0, item, props.getContainer(), _nullishCoalesce(props.targetOffset, () => ( props.offsetTop)));
+    };
+    _vue.onMounted.call(void 0, () => {
+      _vue.nextTick.call(void 0, () => setupObserver());
+    });
+    _vue.watch.call(void 0, 
+      () => [props.items, props.offsetTop, props.targetOffset, props.bounds, props.getContainer],
+      () => _vue.nextTick.call(void 0, () => setupObserver())
+    );
+    _vue.watch.call(void 0, 
+      () => [props.items, props.defaultActiveKey],
+      () => {
+        if (isControlled.value) return;
+        const currentItem = _tigercatcore.getScrollSpyItemByKey.call(void 0, props.items, innerActiveKey.value);
+        if (!currentItem || currentItem.disabled) {
+          innerActiveKey.value = _tigercatcore.getInitialScrollSpyActiveKey.call(void 0, 
+            props.items,
+            void 0,
+            props.defaultActiveKey
+          );
+        }
+      }
+    );
+    _vue.onBeforeUnmount.call(void 0, () => {
+      _optionalChain([stopObserver, 'optionalCall', _2 => _2()]);
+    });
+    const renderItems = (items, nested = false) => _vue.h.call(void 0, 
+      "ul",
+      { class: nested ? _tigercatcore.scrollSpyNestedListClasses : _tigercatcore.getScrollSpyListClasses.call(void 0, props.direction) },
+      items.map((item) => {
+        const keyString = _tigercatcore.getScrollSpyKeyString.call(void 0, item.key);
+        const isActive = keyString === activeKeyString.value;
+        const depth = _nullishCoalesce(_optionalChain([flatItems, 'access', _3 => _3.value, 'access', _4 => _4.find, 'call', _5 => _5((flat) => flat.key === item.key), 'optionalAccess', _6 => _6.depth]), () => ( 0));
+        return _vue.h.call(void 0, "li", { key: keyString, "data-depth": depth }, [
+          _vue.h.call(void 0, 
+            "a",
+            {
+              href: item.href,
+              class: _tigercatcore.getScrollSpyItemClasses.call(void 0, isActive, item.disabled),
+              "aria-current": isActive ? "location" : void 0,
+              "aria-disabled": item.disabled || void 0,
+              "data-key": keyString,
+              onClick: (event) => handleClick(item, event)
+            },
+            item.label
+          ),
+          _optionalChain([item, 'access', _7 => _7.children, 'optionalAccess', _8 => _8.length]) ? renderItems(item.children, true) : null
+        ]);
+      })
+    );
+    return () => {
+      const attrsRecord = attrs;
+      return _vue.h.call(void 0, 
+        "nav",
+        {
+          ...attrs,
+          class: _tigercatcore.classNames.call(void 0, 
+            _tigercatcore.getScrollSpyRootClasses.call(void 0, props.sticky, props.className),
+            _tigercatcore.coerceClassValue.call(void 0, attrsRecord.class)
+          ),
+          style: _tigercatcore.mergeStyleValues.call(void 0, attrsRecord.style, props.style),
+          "aria-label": props.ariaLabel
+        },
+        renderItems(props.items)
+      );
+    };
+  }
+});
+var ScrollSpy_default = ScrollSpy;
+
+
+
+
+exports.ScrollSpy = ScrollSpy; exports.ScrollSpy_default = ScrollSpy_default;

package/dist/chunk-P7RXZVLT.js

@@ -1,27 +1,49 @@
-'use strict';
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/components/AutoComplete.ts
 
-var vue = require('vue');
-var tigercatCore = require('@expcat/tigercat-core');
 
-// src/components/AutoComplete.ts
+
+
+
+
+
+
+var _vue = require('vue');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _tigercatcore = require('@expcat/tigercat-core');
 var autoCompleteInstanceId = 0;
-var ClearIcon = vue.h(
+var ClearIcon = _vue.h.call(void 0, 
   "svg",
   {
     class: "w-4 h-4",
-    viewBox: tigercatCore.icon20ViewBox,
+    viewBox: _tigercatcore.icon20ViewBox,
     fill: "currentColor",
     xmlns: "http://www.w3.org/2000/svg"
   },
   [
-    vue.h("path", {
-      d: tigercatCore.closeSolidIcon20PathD,
+    _vue.h.call(void 0, "path", {
+      d: _tigercatcore.closeSolidIcon20PathD,
       "fill-rule": "evenodd",
       "clip-rule": "evenodd"
     })
   ]
 );
-var AutoComplete = vue.defineComponent({
+var AutoComplete = _vue.defineComponent.call(void 0, {
   name: "TigerAutoComplete",
   props: {
     modelValue: {
@@ -69,27 +91,27 @@ var AutoComplete = vue.defineComponent({
   setup(props, { emit, attrs }) {
     const instanceId = ++autoCompleteInstanceId;
     const listboxId = `tiger-autocomplete-listbox-${instanceId}`;
-    const isOpen = vue.ref(false);
-    const inputValue = vue.ref(String(props.modelValue ?? ""));
-    const activeIndex = vue.ref(-1);
-    const containerRef = vue.ref(null);
-    const inputRef = vue.ref(null);
-    const filteredOptions = vue.computed(
-      () => tigercatCore.filterAutoCompleteOptions(props.options, inputValue.value, props.filterOption)
+    const isOpen = _vue.ref.call(void 0, false);
+    const inputValue = _vue.ref.call(void 0, String(_nullishCoalesce(props.modelValue, () => ( ""))));
+    const activeIndex = _vue.ref.call(void 0, -1);
+    const containerRef = _vue.ref.call(void 0, null);
+    const inputRef = _vue.ref.call(void 0, null);
+    const filteredOptions = _vue.computed.call(void 0, 
+      () => _tigercatcore.filterAutoCompleteOptions.call(void 0, props.options, inputValue.value, props.filterOption)
     );
-    const showClearButton = vue.computed(
+    const showClearButton = _vue.computed.call(void 0, 
       () => props.clearable && !props.disabled && inputValue.value !== ""
     );
-    vue.watch(
+    _vue.watch.call(void 0, 
       () => props.modelValue,
       (val) => {
-        inputValue.value = String(val ?? "");
+        inputValue.value = String(_nullishCoalesce(val, () => ( "")));
       }
     );
     function openDropdown() {
       if (props.disabled) return;
       isOpen.value = true;
-      activeIndex.value = tigercatCore.getInitialPickerActiveIndex(
+      activeIndex.value = _tigercatcore.getInitialPickerActiveIndex.call(void 0, 
         filteredOptions.value,
         props.defaultActiveFirstOption
       );
@@ -106,7 +128,7 @@ var AutoComplete = vue.defineComponent({
       emit("change", val);
       if (!isOpen.value) openDropdown();
       if (props.defaultActiveFirstOption) {
-        activeIndex.value = tigercatCore.getInitialPickerActiveIndex(filteredOptions.value, true);
+        activeIndex.value = _tigercatcore.getInitialPickerActiveIndex.call(void 0, filteredOptions.value, true);
       }
     }
     function handleSelect(option) {
@@ -122,7 +144,7 @@ var AutoComplete = vue.defineComponent({
       inputValue.value = "";
       emit("update:modelValue", "");
       emit("change", "");
-      vue.nextTick(() => inputRef.value?.focus());
+      _vue.nextTick.call(void 0, () => _optionalChain([inputRef, 'access', _ => _.value, 'optionalAccess', _2 => _2.focus, 'call', _3 => _3()]));
     }
     function handleKeyDown(e) {
       if (!isOpen.value) {
@@ -139,7 +161,7 @@ var AutoComplete = vue.defineComponent({
         case "Home":
         case "End":
           e.preventDefault();
-          activeIndex.value = tigercatCore.getPickerNavigationIndex(options, activeIndex.value, e.key);
+          activeIndex.value = _tigercatcore.getPickerNavigationIndex.call(void 0, options, activeIndex.value, e.key);
           break;
         case "Enter":
           e.preventDefault();
@@ -158,20 +180,20 @@ var AutoComplete = vue.defineComponent({
         closeDropdown();
       }
     }
-    vue.watch(isOpen, (val) => {
+    _vue.watch.call(void 0, isOpen, (val) => {
       if (val) {
         document.addEventListener("click", handleClickOutside);
       } else {
         document.removeEventListener("click", handleClickOutside);
       }
     });
-    vue.onBeforeUnmount(() => {
+    _vue.onBeforeUnmount.call(void 0, () => {
       document.removeEventListener("click", handleClickOutside);
     });
     return () => {
-      const containerClasses = tigercatCore.classNames(tigercatCore.autoCompleteBaseClasses, tigercatCore.coerceClassValue(attrs.class));
+      const containerClasses = _tigercatcore.classNames.call(void 0, _tigercatcore.autoCompleteBaseClasses, _tigercatcore.coerceClassValue.call(void 0, attrs.class));
       const options = filteredOptions.value;
-      return vue.h(
+      return _vue.h.call(void 0, 
         "div",
         {
           ref: containerRef,
@@ -179,14 +201,14 @@ var AutoComplete = vue.defineComponent({
         },
         [
           // Input
-          vue.h("input", {
+          _vue.h.call(void 0, "input", {
             ref: inputRef,
             type: "text",
-            class: tigercatCore.getAutoCompleteInputClasses(props.size, props.disabled, isOpen.value),
+            class: _tigercatcore.getAutoCompleteInputClasses.call(void 0, props.size, props.disabled, isOpen.value),
             value: inputValue.value,
             placeholder: props.placeholder,
             disabled: props.disabled,
-            ...tigercatCore.getPickerComboboxAria({
+            ..._tigercatcore.getPickerComboboxAria.call(void 0, {
               expanded: isOpen.value,
               listboxId,
               activeIndex: activeIndex.value
@@ -197,7 +219,7 @@ var AutoComplete = vue.defineComponent({
             onKeydown: handleKeyDown
           }),
           // Clear button
-          showClearButton.value ? vue.h(
+          showClearButton.value ? _vue.h.call(void 0, 
             "button",
             {
               type: "button",
@@ -208,22 +230,22 @@ var AutoComplete = vue.defineComponent({
             [ClearIcon]
           ) : null,
           // Dropdown
-          isOpen.value && options.length > 0 ? vue.h(
+          isOpen.value && options.length > 0 ? _vue.h.call(void 0, 
             "div",
             {
-              ...tigercatCore.getPickerListboxAria({ id: listboxId }),
-              class: tigercatCore.autoCompleteDropdownClasses
+              ..._tigercatcore.getPickerListboxAria.call(void 0, { id: listboxId }),
+              class: _tigercatcore.autoCompleteDropdownClasses
             },
             options.map(
-              (option, index) => vue.h(
+              (option, index) => _vue.h.call(void 0, 
                 "div",
                 {
-                  id: tigercatCore.getPickerOptionId(listboxId, index),
-                  ...tigercatCore.getPickerOptionAria({
+                  id: _tigercatcore.getPickerOptionId.call(void 0, listboxId, index),
+                  ..._tigercatcore.getPickerOptionAria.call(void 0, {
                     selected: String(option.value) === String(props.modelValue),
                     disabled: !!option.disabled
                   }),
-                  class: tigercatCore.getAutoCompleteOptionClasses(
+                  class: _tigercatcore.getAutoCompleteOptionClasses.call(void 0, 
                     String(option.value) === String(props.modelValue),
                     !!option.disabled,
                     props.size
@@ -236,10 +258,10 @@ var AutoComplete = vue.defineComponent({
                 option.label
               )
             )
-          ) : isOpen.value && inputValue.value && options.length === 0 ? vue.h(
+          ) : isOpen.value && inputValue.value && options.length === 0 ? _vue.h.call(void 0, 
             "div",
             {
-              class: tigercatCore.classNames(tigercatCore.autoCompleteDropdownClasses, tigercatCore.autoCompleteEmptyStateClasses)
+              class: _tigercatcore.classNames.call(void 0, _tigercatcore.autoCompleteDropdownClasses, _tigercatcore.autoCompleteEmptyStateClasses)
             },
             props.notFoundText
           ) : null
@@ -250,5 +272,7 @@ var AutoComplete = vue.defineComponent({
 });
 var AutoComplete_default = AutoComplete;
 
-exports.AutoComplete = AutoComplete;
-exports.AutoComplete_default = AutoComplete_default;
+
+
+
+exports.AutoComplete = AutoComplete; exports.AutoComplete_default = AutoComplete_default;

package/dist/chunk-PCJHGWTU.js

@@ -0,0 +1,269 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkJCMGBKS6js = require('./chunk-JCMGBKS6.js');
+
+// src/components/Tour.ts
+
+
+
+
+
+
+
+
+
+var _vue = require('vue');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _tigercatcore = require('@expcat/tigercat-core');
+var Tour = _vue.defineComponent.call(void 0, {
+  name: "TigerTour",
+  inheritAttrs: false,
+  props: {
+    steps: {
+      type: Array,
+      required: true
+    },
+    loadSteps: {
+      type: Function,
+      default: void 0
+    },
+    open: {
+      type: Boolean,
+      default: false
+    },
+    current: {
+      type: Number,
+      default: void 0
+    },
+    nextText: { type: String, default: "Next" },
+    prevText: { type: String, default: "Previous" },
+    finishText: { type: String, default: "Finish" },
+    closable: { type: Boolean, default: true },
+    showIndicators: { type: Boolean, default: true },
+    className: { type: String, default: void 0 }
+  },
+  emits: ["update:open", "update:current", "close", "finish", "change"],
+  setup(props, { emit }) {
+    const internalStep = _vue.ref.call(void 0, 0);
+    const resolvedSteps = _vue.ref.call(void 0, props.steps);
+    const currentStep = _vue.computed.call(void 0, () => _nullishCoalesce(props.current, () => ( internalStep.value)));
+    const activeSteps = _vue.computed.call(void 0, () => _tigercatcore.getActiveTourSteps.call(void 0, resolvedSteps.value));
+    const activeStepInfo = _vue.computed.call(void 0, 
+      () => _tigercatcore.getCurrentActiveTourStep.call(void 0, activeSteps.value, currentStep.value, resolvedSteps.value.length)
+    );
+    const activeStepPosition = _vue.computed.call(void 0, 
+      () => _tigercatcore.getActiveTourStepPosition.call(void 0, activeSteps.value, _optionalChain([activeStepInfo, 'access', _ => _.value, 'optionalAccess', _2 => _2.index]))
+    );
+    const step = _vue.computed.call(void 0, () => _optionalChain([activeStepInfo, 'access', _3 => _3.value, 'optionalAccess', _4 => _4.step]));
+    const targetRect = _vue.ref.call(void 0, );
+    const popoverRef = _vue.ref.call(void 0, null);
+    const updateRect = () => {
+      if (_optionalChain([step, 'access', _5 => _5.value, 'optionalAccess', _6 => _6.target])) {
+        targetRect.value = _tigercatcore.getTourTargetRect.call(void 0, step.value.target);
+      } else {
+        targetRect.value = void 0;
+      }
+    };
+    const loadSteps = async () => {
+      if (!props.loadSteps) {
+        resolvedSteps.value = props.steps;
+        return;
+      }
+      resolvedSteps.value = await props.loadSteps();
+    };
+    _vue.watch.call(void 0, 
+      () => props.steps,
+      (next2) => {
+        if (!props.loadSteps) {
+          resolvedSteps.value = next2;
+        }
+      }
+    );
+    _vue.watch.call(void 0, 
+      () => props.open,
+      (open) => {
+        if (open) void loadSteps();
+      },
+      { immediate: true }
+    );
+    _vue.watch.call(void 0, 
+      () => [props.open, currentStep.value],
+      () => {
+        if (props.open) updateRect();
+      }
+    );
+    _vue.onMounted.call(void 0, () => {
+      if (props.open) updateRect();
+    });
+    let resizeHandler;
+    _vue.onMounted.call(void 0, () => {
+      resizeHandler = () => {
+        if (props.open) updateRect();
+      };
+      window.addEventListener("resize", resizeHandler);
+      window.addEventListener("scroll", resizeHandler, true);
+    });
+    _vue.onBeforeUnmount.call(void 0, () => {
+      if (resizeHandler) {
+        window.removeEventListener("resize", resizeHandler);
+        window.removeEventListener("scroll", resizeHandler, true);
+      }
+    });
+    const goTo = (idx) => {
+      internalStep.value = idx;
+      emit("update:current", idx);
+      emit("change", idx);
+    };
+    const next = () => {
+      const nextStep = activeSteps.value[activeStepPosition.value + 1];
+      if (nextStep) {
+        goTo(nextStep.index);
+      } else {
+        emit("finish");
+        emit("update:open", false);
+      }
+    };
+    const prev = () => {
+      const prevStep = activeSteps.value[activeStepPosition.value - 1];
+      if (prevStep) {
+        goTo(prevStep.index);
+      }
+    };
+    const close = () => {
+      emit("close");
+      emit("update:open", false);
+    };
+    return () => {
+      if (!props.open || !step.value) return null;
+      const placement = _nullishCoalesce(step.value.placement, () => ( "bottom"));
+      const showMask = step.value.mask !== false;
+      const isLast = activeStepPosition.value === activeSteps.value.length - 1;
+      const isFirst = activeStepPosition.value <= 0;
+      let popoverStyle = {};
+      if (targetRect.value) {
+        const pos = _tigercatcore.getTourPopoverPosition.call(void 0, targetRect.value, 320, 160, placement);
+        popoverStyle = {
+          position: "absolute",
+          top: `${pos.top}px`,
+          left: `${pos.left}px`
+        };
+      } else {
+        popoverStyle = {
+          position: "fixed",
+          top: "50%",
+          left: "50%",
+          transform: "translate(-50%, -50%)"
+        };
+      }
+      const children = [];
+      if (showMask && targetRect.value) {
+        children.push(
+          _vue.h.call(void 0, "div", {
+            style: _tigercatcore.getTourSpotlightStyle.call(void 0, targetRect.value),
+            "aria-hidden": "true"
+          })
+        );
+      } else if (showMask) {
+        children.push(
+          _vue.h.call(void 0, "div", {
+            class: "fixed inset-0 z-[1000] bg-black/45",
+            "aria-hidden": "true",
+            onClick: close
+          })
+        );
+      }
+      const popoverChildren = [];
+      if (props.closable) {
+        popoverChildren.push(
+          _vue.h.call(void 0, 
+            "button",
+            {
+              class: _tigercatcore.tourCloseButtonClasses,
+              type: "button",
+              "aria-label": "Close tour",
+              onClick: close
+            },
+            _chunkJCMGBKS6js.createStatusIcon.call(void 0, _tigercatcore.closeIconPathD, "h-4 w-4")
+          )
+        );
+      }
+      if (step.value.title) {
+        popoverChildren.push(_vue.h.call(void 0, "div", { class: _tigercatcore.tourTitleClasses }, step.value.title));
+      }
+      if (step.value.description) {
+        popoverChildren.push(_vue.h.call(void 0, "div", { class: _tigercatcore.tourDescriptionClasses }, step.value.description));
+      }
+      const footerChildren = [];
+      if (props.showIndicators) {
+        footerChildren.push(
+          _vue.h.call(void 0, 
+            "span",
+            { class: _tigercatcore.tourIndicatorClasses },
+            `${activeStepPosition.value + 1} / ${activeSteps.value.length}`
+          )
+        );
+      }
+      const buttons = [];
+      if (!isFirst) {
+        buttons.push(
+          _vue.h.call(void 0, 
+            "button",
+            {
+              type: "button",
+              class: "px-3 py-1.5 text-sm rounded-md border border-[var(--tiger-border,#e5e7eb)] text-[var(--tiger-text,#111827)] hover:bg-[var(--tiger-surface-muted,#f9fafb)] transition-colors mr-2",
+              onClick: prev
+            },
+            props.prevText
+          )
+        );
+      }
+      buttons.push(
+        _vue.h.call(void 0, 
+          "button",
+          {
+            type: "button",
+            class: "px-3 py-1.5 text-sm rounded-md bg-[var(--tiger-primary,#2563eb)] text-white hover:bg-[var(--tiger-primary-hover,#1d4ed8)] transition-colors",
+            onClick: next
+          },
+          isLast ? props.finishText : props.nextText
+        )
+      );
+      footerChildren.push(_vue.h.call(void 0, "div", { class: "flex items-center" }, buttons));
+      popoverChildren.push(_vue.h.call(void 0, "div", { class: _tigercatcore.tourFooterClasses }, footerChildren));
+      children.push(
+        _vue.h.call(void 0, 
+          "div",
+          {
+            ref: popoverRef,
+            class: _tigercatcore.classNames.call(void 0, _tigercatcore.tourPopoverClasses, props.className),
+            style: popoverStyle,
+            role: "dialog",
+            "aria-modal": "true"
+          },
+          popoverChildren
+        )
+      );
+      return _vue.h.call(void 0, _vue.Teleport, { to: "body" }, children);
+    };
+  }
+});
+var Tour_default = Tour;
+
+
+
+
+exports.Tour = Tour; exports.Tour_default = Tour_default;