@expcat/tigercat-vue 0.4.3 → 1.0.4

package/dist/{chunk-ATGOHL6L.mjs → chunk-243JSTYQ.mjs}

@@ -1,4 +1,4 @@
-import { useFloatingPopup } from './chunk-WIPPSHI6.mjs';
+import { useFloatingPopup } from './chunk-6A57RY3H.mjs';
 import { defineComponent, computed, isVNode, h, cloneVNode } from 'vue';
 import { createFloatingIdFactory, classNames, getPopconfirmContainerClasses, coerceClassValue, getPopconfirmTriggerClasses, getPopconfirmArrowClasses, getPopconfirmContentClasses, getPopconfirmTitleClasses, getPopconfirmDescriptionClasses, getPopconfirmButtonsClasses, getPopconfirmCancelButtonClasses, getPopconfirmIconClasses, getPopconfirmOkButtonClasses, mergeStyleValues, popconfirmIconViewBox, popconfirmIconStrokeWidth, getPopconfirmIconPath, popconfirmIconPathStrokeLinejoin, popconfirmIconPathStrokeLinecap } from '@expcat/tigercat-core';
 
@@ -26,10 +26,10 @@ var Popconfirm = defineComponent({
   name: "TigerPopconfirm",
   inheritAttrs: false,
   props: {
-    /** Whether the popconfirm is visible (controlled mode) */
-    visible: { type: Boolean, default: void 0 },
-    /** Default visibility (uncontrolled mode) @default false */
-    defaultVisible: { type: Boolean, default: false },
+    /** Whether the popconfirm is open (controlled mode) */
+    open: { type: Boolean, default: void 0 },
+    /** Default open state (uncontrolled mode) @default false */
+    defaultOpen: { type: Boolean, default: false },
     /** Popconfirm title/question text */
     title: { type: String, default: "\u786E\u5B9A\u8981\u6267\u884C\u6B64\u64CD\u4F5C\u5417\uFF1F" },
     /** Popconfirm description text */
@@ -57,7 +57,7 @@ var Popconfirm = defineComponent({
     className: { type: String, default: void 0 },
     style: { type: [String, Object, Array], default: void 0 }
   },
-  emits: ["update:visible", "visible-change", "confirm", "cancel"],
+  emits: ["update:open", "open-change", "confirm", "cancel"],
   setup(props, { slots, emit, attrs }) {
     const {
       currentVisible,

package/dist/chunk-2S5CNU36.js

@@ -0,0 +1,163 @@
+'use strict';
+
+var vue = require('vue');
+var tigercatCore = require('@expcat/tigercat-core');
+
+// src/components/FloatButton.ts
+var FloatButton = vue.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 = vue.computed(
+      () => tigercatCore.classNames(
+        tigercatCore.floatButtonBaseClasses,
+        tigercatCore.floatButtonShapeClasses[props.shape],
+        tigercatCore.floatButtonSizeClasses[props.size],
+        tigercatCore.floatButtonTypeClasses[props.type],
+        props.disabled && tigercatCore.floatButtonDisabledClasses,
+        props.className,
+        tigercatCore.coerceClassValue(attrs.class)
+      )
+    );
+    const handleClick = (e) => {
+      if (!props.disabled) {
+        emit("click", e);
+      }
+    };
+    return () => {
+      const attrsRecord = attrs;
+      const btn = vue.h(
+        "button",
+        {
+          ...attrs,
+          class: classes.value,
+          style: tigercatCore.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 = vue.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 = vue.ref(false);
+    const isOpen = vue.computed(() => props.open ?? internalOpen.value);
+    const toggle = () => {
+      const next = !isOpen.value;
+      internalOpen.value = next;
+      emit("update:open", next);
+    };
+    const groupClasses = vue.computed(
+      () => tigercatCore.classNames(
+        tigercatCore.floatButtonGroupClasses,
+        props.className,
+        tigercatCore.coerceClassValue(attrs.class)
+      )
+    );
+    return () => {
+      const attrsRecord = attrs;
+      const children = [];
+      if (slots.trigger) {
+        children.push(
+          vue.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 vue.h(vue.Teleport, { to: "body" }, [
+        vue.h(
+          "div",
+          {
+            ...attrs,
+            class: groupClasses.value,
+            style: tigercatCore.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;
+
+exports.FloatButton = FloatButton;
+exports.FloatButtonGroup = FloatButtonGroup;
+exports.FloatButton_default = FloatButton_default;

package/dist/{chunk-ROKUXJBS.js → chunk-2SK6T4WB.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkOOKS4KMK_js = require('./chunk-OOKS4KMK.js');
+var chunkJCMGBKS6_js = require('./chunk-JCMGBKS6.js');
 var vue = require('vue');
 var tigercatCore = require('@expcat/tigercat-core');
 
@@ -88,7 +88,7 @@ var NotificationContainer = vue.defineComponent({
         );
       }
       const children = [
-        chunkOOKS4KMK_js.createStatusIcon(iconPath, iconClass, { "aria-hidden": "true", focusable: "false" }),
+        chunkJCMGBKS6_js.createStatusIcon(iconPath, iconClass, { "aria-hidden": "true", focusable: "false" }),
         vue.h("div", { class: tigercatCore.notificationContentClasses }, contentChildren)
       ];
       if (notification2.closable) {
@@ -104,7 +104,7 @@ var NotificationContainer = vue.defineComponent({
               "aria-label": NOTIFICATION_CLOSE_ARIA_LABEL,
               type: "button"
             },
-            chunkOOKS4KMK_js.createStatusIcon(tigercatCore.notificationCloseIconPath, tigercatCore.notificationCloseIconClasses, { "aria-hidden": "true", focusable: "false" })
+            chunkJCMGBKS6_js.createStatusIcon(tigercatCore.notificationCloseIconPath, tigercatCore.notificationCloseIconClasses, { "aria-hidden": "true", focusable: "false" })
           )
         );
       }

package/dist/{chunk-7RRA3TIG.mjs → chunk-2TNZ4JNT.mjs}

@@ -1,7 +1,25 @@
 import { h } from 'vue';
-import { icon24ViewBox, icon24StrokeWidth, icon24PathStrokeLinejoin, icon24PathStrokeLinecap, classNames } from '@expcat/tigercat-core';
+import { icon20ViewBox, icon24ViewBox, icon24StrokeWidth, icon24PathStrokeLinejoin, icon24PathStrokeLinecap, classNames } from '@expcat/tigercat-core';
 
 // src/utils/icon-helpers.ts
+function createFilledIcon(path, className) {
+  return h(
+    "svg",
+    {
+      class: className,
+      xmlns: "http://www.w3.org/2000/svg",
+      viewBox: icon20ViewBox,
+      fill: "currentColor"
+    },
+    [
+      h("path", {
+        "fill-rule": "evenodd",
+        d: path,
+        "clip-rule": "evenodd"
+      })
+    ]
+  );
+}
 function createStatusIcon(path, className, extraAttrs) {
   return h(
     "svg",
@@ -28,4 +46,4 @@ function createStatusIconWithLoading(path, className, isLoading, spinnerClass) {
   return createStatusIcon(path, merged);
 }
 
-export { createStatusIcon, createStatusIconWithLoading };
+export { createFilledIcon, createStatusIcon, createStatusIconWithLoading };

package/dist/chunk-2WJADO6O.mjs

@@ -0,0 +1,298 @@
+import { defineComponent, ref, watch, computed, h } from 'vue';
+import { injectShakeStyle, SHAKE_CLASS, getInputClasses, getInputErrorClasses, getInputClearButtonClasses, getInputPasswordToggleClasses, getInputAffixClasses, classNames, getInputWrapperClasses, coerceClassValue, getInputCountClasses, parseInputValue } from '@expcat/tigercat-core';
+
+// src/components/Input.ts
+var inputIdCounter = 0;
+var Input = defineComponent({
+  name: "TigerInput",
+  inheritAttrs: false,
+  props: {
+    /**
+     * Input value (for v-model)
+     */
+    modelValue: {
+      type: [String, Number]
+    },
+    /**
+     * Input size
+     * @default 'md'
+     */
+    size: {
+      type: String,
+      default: "md"
+    },
+    /**
+     * Input type
+     * @default 'text'
+     */
+    type: {
+      type: String,
+      default: "text"
+    },
+    /**
+     * Input status
+     * @default 'default'
+     */
+    status: {
+      type: String,
+      default: "default"
+    },
+    /**
+     * Error message to default display
+     */
+    errorMessage: String,
+    /**
+     * Prefix text/icon
+     */
+    prefix: String,
+    /**
+     * Suffix text/icon
+     */
+    suffix: String,
+    /**
+     * Placeholder text
+     */
+    placeholder: {
+      type: String,
+      default: ""
+    },
+    /**
+     * Whether the input is disabled
+     */
+    disabled: Boolean,
+    /**
+     * Whether the input is readonly
+     */
+    readonly: Boolean,
+    /**
+     * Whether the input is required
+     */
+    required: Boolean,
+    /** Maximum length */
+    maxLength: Number,
+    /** Minimum length */
+    minLength: Number,
+    /** Input name attribute */
+    name: String,
+    /** Input id attribute */
+    id: String,
+    /** Autocomplete attribute */
+    autoComplete: String,
+    /**
+     * Whether to autofocus on mount
+     */
+    autoFocus: Boolean,
+    /**
+     * Whether to show a clear button
+     */
+    clearable: Boolean,
+    /**
+     * Whether to show a password toggle button
+     */
+    showPassword: Boolean,
+    /**
+     * Whether to show a character count
+     */
+    showCount: Boolean,
+    /**
+     * Internal shake trigger counter (used by FormItem)
+     * @internal
+     */
+    _shakeTrigger: {
+      type: Number,
+      default: void 0
+    },
+    /** Additional CSS classes */
+    className: String,
+    /**
+     * Inline styles
+     */
+    style: {
+      type: Object
+    }
+  },
+  emits: {
+    "update:modelValue": null,
+    input: null,
+    change: null,
+    focus: null,
+    blur: null,
+    clear: null
+  },
+  setup(props, { emit, attrs, slots }) {
+    injectShakeStyle();
+    const inputRef = ref(null);
+    const wrapperRef = ref(null);
+    const localValue = ref(props.modelValue ?? "");
+    const passwordVisible = ref(false);
+    const instanceId = ++inputIdCounter;
+    const errorMsgId = `tiger-input-error-${instanceId}`;
+    watch(
+      () => props.modelValue,
+      (newValue) => {
+        const next = newValue ?? "";
+        if (next !== localValue.value) {
+          localValue.value = next;
+        }
+      }
+    );
+    watch([() => props.status, () => props._shakeTrigger], ([newStatus]) => {
+      if (newStatus === "error" && wrapperRef.value) {
+        const el = wrapperRef.value;
+        el.classList.remove(SHAKE_CLASS);
+        void el.offsetWidth;
+        el.classList.add(SHAKE_CLASS);
+      }
+    });
+    const handleAnimationEnd = () => {
+      wrapperRef.value?.classList.remove(SHAKE_CLASS);
+    };
+    const hasPrefix = computed(() => !!slots.prefix || !!props.prefix);
+    const hasSuffix = computed(
+      () => !!slots.suffix || !!props.suffix || props.clearable || props.showPassword
+    );
+    const activeError = computed(() => props.status === "error" && !!props.errorMessage);
+    const inputClasses = computed(
+      () => getInputClasses({
+        size: props.size,
+        status: props.status,
+        hasPrefix: hasPrefix.value,
+        hasSuffix: hasSuffix.value
+      })
+    );
+    const effectiveType = computed(() => {
+      if (props.showPassword && props.type === "password") {
+        return passwordVisible.value ? "text" : "password";
+      }
+      return props.type;
+    });
+    const handleInput = (event) => {
+      const target = event.target;
+      const value = parseInputValue(target, props.type);
+      localValue.value = value;
+      emit("update:modelValue", value);
+      emit("input", event);
+    };
+    const handleChange = (event) => emit("change", event);
+    const handleFocus = (event) => emit("focus", event);
+    const handleBlur = (event) => emit("blur", event);
+    const handleClear = () => {
+      localValue.value = "";
+      emit("update:modelValue", "");
+      emit("clear");
+      inputRef.value?.focus();
+    };
+    const togglePasswordVisibility = () => {
+      passwordVisible.value = !passwordVisible.value;
+    };
+    return () => {
+      const { class: attrClass, style: attrStyle, ...restAttrs } = attrs;
+      const currentValStr = String(localValue.value);
+      const showClear = props.clearable && !props.disabled && !props.readonly && currentValStr.length > 0;
+      const showPasswordToggle = props.showPassword && props.type === "password" && !props.disabled;
+      const suffixNodes = [];
+      if (activeError.value) {
+        suffixNodes.push(
+          h("div", { id: errorMsgId, class: getInputErrorClasses(props.size) }, props.errorMessage)
+        );
+      } else {
+        if (showClear) {
+          suffixNodes.push(
+            h(
+              "button",
+              {
+                type: "button",
+                class: getInputClearButtonClasses(props.size),
+                onClick: handleClear,
+                "aria-label": "Clear input",
+                tabindex: -1
+              },
+              "\u2715"
+            )
+          );
+        }
+        if (showPasswordToggle) {
+          suffixNodes.push(
+            h(
+              "button",
+              {
+                type: "button",
+                class: getInputPasswordToggleClasses(props.size),
+                onClick: togglePasswordVisibility,
+                "aria-label": passwordVisible.value ? "Hide password" : "Show password",
+                tabindex: -1
+              },
+              passwordVisible.value ? "\u{1F648}" : "\u{1F441}"
+            )
+          );
+        }
+        if (!showClear && !showPasswordToggle && hasSuffix.value) {
+          suffixNodes.push(
+            h(
+              "div",
+              { class: getInputAffixClasses("suffix", props.size) },
+              slots.suffix ? slots.suffix() : props.suffix
+            )
+          );
+        }
+      }
+      const wrapperChildren = [
+        hasPrefix.value && h(
+          "div",
+          { class: getInputAffixClasses("prefix", props.size) },
+          slots.prefix ? slots.prefix() : props.prefix
+        ),
+        h("input", {
+          ...restAttrs,
+          ref: inputRef,
+          class: inputClasses.value,
+          type: effectiveType.value,
+          value: localValue.value,
+          placeholder: props.placeholder,
+          disabled: props.disabled,
+          readonly: props.readonly,
+          required: props.required,
+          maxlength: props.maxLength,
+          minlength: props.minLength,
+          name: props.name,
+          id: props.id,
+          autocomplete: props.autoComplete,
+          autofocus: props.autoFocus,
+          ...props.status === "error" ? { "aria-invalid": true } : {},
+          ...activeError.value ? { "aria-describedby": errorMsgId } : {},
+          onInput: handleInput,
+          onChange: handleChange,
+          onFocus: handleFocus,
+          onBlur: handleBlur
+        }),
+        ...suffixNodes
+      ];
+      const nodes = [
+        h(
+          "div",
+          {
+            ref: wrapperRef,
+            class: classNames(
+              getInputWrapperClasses(),
+              props.className,
+              coerceClassValue(attrClass)
+            ),
+            style: [attrStyle, props.style],
+            onAnimationend: handleAnimationEnd
+          },
+          wrapperChildren
+        )
+      ];
+      if (props.showCount) {
+        const count = currentValStr.length;
+        const isOver = props.maxLength !== void 0 && count > props.maxLength;
+        const countText = props.maxLength !== void 0 ? `${count} / ${props.maxLength}` : `${count}`;
+        nodes.push(h("div", { class: getInputCountClasses(isOver) }, countText));
+      }
+      return nodes.length === 1 ? nodes[0] : h("div", null, nodes);
+    };
+  }
+});
+var Input_default = Input;
+
+export { Input, Input_default };

package/dist/{chunk-BFNHRBWN.js → chunk-2WZGK7XJ.js}

@@ -6,22 +6,22 @@ var tigercatCore = require('@expcat/tigercat-core');
 
 function useFloatingPopup(options) {
   const { props, emit, multiTrigger = true } = options;
-  const internalVisible = vue.ref(props.visible ?? props.defaultVisible ?? false);
-  const isControlled = vue.computed(() => props.visible !== void 0);
+  const internalVisible = vue.ref(props.open ?? props.defaultOpen ?? false);
+  const isControlled = vue.computed(() => props.open !== void 0);
   vue.watch(
-    () => props.visible,
+    () => props.open,
     (next) => {
       if (next !== void 0) internalVisible.value = next;
     }
   );
   const currentVisible = vue.computed(
-    () => isControlled.value ? Boolean(props.visible) : internalVisible.value
+    () => isControlled.value ? Boolean(props.open) : internalVisible.value
   );
   const setVisible = (next) => {
     if (props.disabled && next) return;
     if (!isControlled.value) internalVisible.value = next;
-    emit("update:visible", next);
-    emit("visible-change", next);
+    emit("update:open", next);
+    emit("open-change", next);
   };
   const containerRef = vue.ref(null);
   const triggerRef = vue.ref(null);