@expcat/tigercat-vue 2.0.19 → 2.1.1

package/dist/components/InputOTP.d.mts

@@ -0,0 +1,261 @@
+import * as vue from 'vue';
+import { PropType } from 'vue';
+import { ComponentSize, InputStatus, InputOTPType } from '@expcat/tigercat-core';
+
+type VueInputOTPProps = InstanceType<typeof InputOTP>['$props'];
+declare const InputOTP: vue.DefineComponent<vue.ExtractPropTypes<{
+    /**
+     * Value (for v-model) — the joined characters
+     */
+    modelValue: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    /**
+     * Default value (for uncontrolled mode)
+     */
+    defaultValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * Input size
+     * @default 'md'
+     */
+    size: {
+        type: PropType<ComponentSize>;
+        default: string;
+    };
+    /**
+     * Validation status
+     * @default 'default'
+     */
+    status: {
+        type: PropType<InputStatus>;
+        default: string;
+    };
+    /**
+     * Error message to display
+     */
+    errorMessage: StringConstructor;
+    /**
+     * Number of character slots
+     * @default 6
+     */
+    length: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /**
+     * Allowed character set
+     * @default 'numeric'
+     */
+    type: {
+        type: PropType<InputOTPType>;
+        default: string;
+    };
+    /**
+     * Per-character validation regex; overrides `type` filtering
+     */
+    pattern: {
+        type: PropType<RegExp>;
+        default: undefined;
+    };
+    /**
+     * Hide entered characters (renders maskChar instead)
+     */
+    masked: BooleanConstructor;
+    /**
+     * Character shown per filled slot when masked
+     * @default '•'
+     */
+    maskChar: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * Visual slot grouping, e.g. [3, 3]
+     */
+    groups: {
+        type: PropType<number[]>;
+        default: undefined;
+    };
+    /**
+     * Separator rendered between groups
+     * @default '-'
+     */
+    separator: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** Whether the input is disabled */
+    disabled: BooleanConstructor;
+    /** Whether the input is readonly */
+    readonly: BooleanConstructor;
+    /** Whether to autofocus the first empty slot on mount */
+    autoFocus: BooleanConstructor;
+    /** Name for the hidden input carrying the joined value */
+    name: StringConstructor;
+    /** Id attribute applied to the group element */
+    id: StringConstructor;
+    /** Accessible label for the slot group */
+    ariaLabel: StringConstructor;
+    /**
+     * Internal shake trigger counter (used by FormItem)
+     * @internal
+     */
+    _shakeTrigger: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    /** Additional CSS classes */
+    className: StringConstructor;
+    /** Inline styles */
+    style: {
+        type: PropType<Record<string, string | number>>;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    'update:modelValue': null;
+    complete: null;
+    focus: null;
+    blur: null;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    /**
+     * Value (for v-model) — the joined characters
+     */
+    modelValue: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    /**
+     * Default value (for uncontrolled mode)
+     */
+    defaultValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * Input size
+     * @default 'md'
+     */
+    size: {
+        type: PropType<ComponentSize>;
+        default: string;
+    };
+    /**
+     * Validation status
+     * @default 'default'
+     */
+    status: {
+        type: PropType<InputStatus>;
+        default: string;
+    };
+    /**
+     * Error message to display
+     */
+    errorMessage: StringConstructor;
+    /**
+     * Number of character slots
+     * @default 6
+     */
+    length: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /**
+     * Allowed character set
+     * @default 'numeric'
+     */
+    type: {
+        type: PropType<InputOTPType>;
+        default: string;
+    };
+    /**
+     * Per-character validation regex; overrides `type` filtering
+     */
+    pattern: {
+        type: PropType<RegExp>;
+        default: undefined;
+    };
+    /**
+     * Hide entered characters (renders maskChar instead)
+     */
+    masked: BooleanConstructor;
+    /**
+     * Character shown per filled slot when masked
+     * @default '•'
+     */
+    maskChar: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * Visual slot grouping, e.g. [3, 3]
+     */
+    groups: {
+        type: PropType<number[]>;
+        default: undefined;
+    };
+    /**
+     * Separator rendered between groups
+     * @default '-'
+     */
+    separator: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** Whether the input is disabled */
+    disabled: BooleanConstructor;
+    /** Whether the input is readonly */
+    readonly: BooleanConstructor;
+    /** Whether to autofocus the first empty slot on mount */
+    autoFocus: BooleanConstructor;
+    /** Name for the hidden input carrying the joined value */
+    name: StringConstructor;
+    /** Id attribute applied to the group element */
+    id: StringConstructor;
+    /** Accessible label for the slot group */
+    ariaLabel: StringConstructor;
+    /**
+     * Internal shake trigger counter (used by FormItem)
+     * @internal
+     */
+    _shakeTrigger: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    /** Additional CSS classes */
+    className: StringConstructor;
+    /** Inline styles */
+    style: {
+        type: PropType<Record<string, string | number>>;
+        default: undefined;
+    };
+}>> & Readonly<{
+    onBlur?: ((...args: any[]) => any) | undefined;
+    onFocus?: ((...args: any[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    onComplete?: ((...args: any[]) => any) | undefined;
+}>, {
+    size: ComponentSize;
+    groups: number[];
+    style: Record<string, string | number>;
+    status: InputStatus;
+    type: InputOTPType;
+    length: number;
+    disabled: boolean;
+    pattern: RegExp;
+    modelValue: string;
+    defaultValue: string;
+    separator: string;
+    readonly: boolean;
+    masked: boolean;
+    autoFocus: boolean;
+    maskChar: string;
+    _shakeTrigger: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+export { InputOTP, type VueInputOTPProps, InputOTP as default };

package/dist/components/InputOTP.mjs

@@ -0,0 +1,11 @@
+import {
+  InputOTP,
+  InputOTP_default
+} from "../chunk-UUWPSRNV.mjs";
+import "../chunk-P2LZ2MR5.mjs";
+import "../chunk-UOJOJBEU.mjs";
+import "../chunk-TGXBCKOU.mjs";
+export {
+  InputOTP,
+  InputOTP_default as default
+};

package/dist/components/Kanban.d.mts

@@ -177,9 +177,9 @@ declare const Kanban: vue.DefineComponent<vue.ExtractPropTypes<{
     "onColumn-add"?: ((...args: any[]) => any) | undefined;
     "onUpdate:columns"?: ((...args: any[]) => any) | undefined;
 }>, {
+    locale: Partial<TigerLocale>;
     className: string;
     style: Record<string, string | number>;
-    locale: Partial<TigerLocale>;
     columns: TaskBoardColumn[];
     columnDraggable: boolean;
     draggable: boolean;

package/dist/components/Kanban.mjs

@@ -1,8 +1,8 @@
 import {
   Kanban,
   Kanban_default
-} from "../chunk-U75YXWSA.mjs";
-import "../chunk-EGIMTTZA.mjs";
+} from "../chunk-CLTRADS7.mjs";
+import "../chunk-BOHE5URZ.mjs";
 import "../chunk-UOJOJBEU.mjs";
 import "../chunk-TGXBCKOU.mjs";
 export {

package/dist/components/Kbd.d.mts

@@ -0,0 +1,118 @@
+import * as vue from 'vue';
+import { PropType } from 'vue';
+import { KbdSize, KbdVariant } from '@expcat/tigercat-core';
+
+interface VueKbdProps {
+    keys?: string | string[];
+    separator?: string;
+    size?: KbdSize;
+    variant?: KbdVariant;
+    className?: string;
+    style?: Record<string, unknown>;
+}
+declare const Kbd: vue.DefineComponent<vue.ExtractPropTypes<{
+    /**
+     * One key or a combo list. A string is a single key; an array is joined
+     * with `separator`. Combine with the default slot to append a final key.
+     */
+    keys: {
+        type: PropType<string | string[]>;
+        default: undefined;
+    };
+    /**
+     * Separator between combo keys
+     * @default '+'
+     */
+    separator: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    /**
+     * Visual size
+     * @default 'md'
+     */
+    size: {
+        type: PropType<KbdSize>;
+        default: string;
+    };
+    /**
+     * Visual variant. `default` reuses Tag default chrome; `subtle` is quieter.
+     * @default 'default'
+     */
+    variant: {
+        type: PropType<KbdVariant>;
+        default: string;
+    };
+    /**
+     * Additional CSS classes
+     */
+    className: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    /**
+     * Inline styles
+     */
+    style: {
+        type: PropType<Record<string, unknown>>;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    /**
+     * One key or a combo list. A string is a single key; an array is joined
+     * with `separator`. Combine with the default slot to append a final key.
+     */
+    keys: {
+        type: PropType<string | string[]>;
+        default: undefined;
+    };
+    /**
+     * Separator between combo keys
+     * @default '+'
+     */
+    separator: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    /**
+     * Visual size
+     * @default 'md'
+     */
+    size: {
+        type: PropType<KbdSize>;
+        default: string;
+    };
+    /**
+     * Visual variant. `default` reuses Tag default chrome; `subtle` is quieter.
+     * @default 'default'
+     */
+    variant: {
+        type: PropType<KbdVariant>;
+        default: string;
+    };
+    /**
+     * Additional CSS classes
+     */
+    className: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    /**
+     * Inline styles
+     */
+    style: {
+        type: PropType<Record<string, unknown>>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    size: KbdSize;
+    keys: string | string[];
+    className: string;
+    style: Record<string, unknown>;
+    variant: KbdVariant;
+    separator: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+export { Kbd, type VueKbdProps, Kbd as default };

package/dist/components/Kbd.mjs

@@ -0,0 +1,8 @@
+import {
+  Kbd,
+  Kbd_default
+} from "../chunk-AECXFT7D.mjs";
+export {
+  Kbd,
+  Kbd_default as default
+};

package/dist/components/LineChart.d.mts

@@ -413,11 +413,11 @@ declare const LineChart: vue.DefineComponent<vue.ExtractPropTypes<{
     "onSeries-click"?: ((...args: any[]) => any) | undefined;
     "onSeries-hover"?: ((...args: any[]) => any) | undefined;
 }>, {
-    width: number;
-    height: number;
     padding: ChartPadding;
     hoverable: boolean;
     strokeWidth: number;
+    width: number;
+    height: number;
     selectable: boolean;
     responsive: boolean;
     xTicks: number;

package/dist/components/LineChart.mjs

@@ -1,14 +1,15 @@
 import {
   LineChart,
   LineChart_default
-} from "../chunk-XGXZF27U.mjs";
-import "../chunk-PE5OA4YG.mjs";
+} from "../chunk-6NYC7EY2.mjs";
+import "../chunk-UEGNXN5B.mjs";
+import "../chunk-FHUGOSEY.mjs";
+import "../chunk-2ZUEXCVJ.mjs";
 import "../chunk-SPFL55TF.mjs";
 import "../chunk-ZWVA7HT3.mjs";
-import "../chunk-W5RZPTFD.mjs";
+import "../chunk-SNNT64HK.mjs";
 import "../chunk-MI6TL3CQ.mjs";
 import "../chunk-V443QIJM.mjs";
-import "../chunk-2ZUEXCVJ.mjs";
 export {
   LineChart,
   LineChart_default as default

package/dist/components/Link.d.mts

@@ -81,9 +81,9 @@ declare const Link: vue.DefineComponent<vue.ExtractPropTypes<{
     onClick?: ((event: MouseEvent) => any) | undefined;
 }>, {
     size: LinkSize;
-    disabled: boolean;
     variant: LinkVariant;
     underline: boolean;
+    disabled: boolean;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
 export { Link, type VueLinkProps, Link as default };

package/dist/components/List.d.mts

@@ -295,18 +295,18 @@ declare const List: vue.DefineComponent<vue.ExtractPropTypes<{
     "onItem-click"?: ((...args: any[]) => any) | undefined;
     onReorder?: ((...args: any[]) => any) | undefined;
 }>, {
+    size: ComponentSize;
+    loading: boolean;
+    emptyText: string;
+    locale: Partial<TigerLocale>;
     className: string;
     style: Record<string, string | number>;
-    locale: Partial<TigerLocale>;
     pagination: false | ListPaginationConfig;
-    emptyText: string;
-    size: ComponentSize;
-    loading: boolean;
-    virtual: boolean;
-    dataSource: ListItem[];
-    split: boolean;
     bordered: ListBorderStyle;
     hoverable: boolean;
+    split: boolean;
+    virtual: boolean;
+    dataSource: ListItem[];
     rowKey: string | ((item: ListItem, index: number) => string | number);
     virtualHeight: number;
     virtualItemHeight: number;

package/dist/components/List.mjs

@@ -1,8 +1,8 @@
 import {
   List,
   List_default
-} from "../chunk-KOG3HKOF.mjs";
-import "../chunk-2LIIMWBR.mjs";
+} from "../chunk-GQOPDD44.mjs";
+import "../chunk-OYU47A57.mjs";
 import "../chunk-HS4YQGZQ.mjs";
 import "../chunk-UOJOJBEU.mjs";
 import "../chunk-TGXBCKOU.mjs";

package/dist/components/Loading.d.mts

@@ -59,9 +59,9 @@ declare const Loading: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<Partial<TigerLocale>>;
         default: undefined;
     };
-}>, () => string | number | boolean | void | vue.VNode<vue.RendererNode, vue.RendererElement, {
+}>, () => string | number | boolean | void | vue.VNodeArrayChildren | vue.VNode<vue.RendererNode, vue.RendererElement, {
     [key: string]: any;
-}> | vue.VNodeArrayChildren | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
     variant: {
         type: PropType<LoadingVariant>;
         default: LoadingVariant;
@@ -115,19 +115,19 @@ declare const Loading: vue.DefineComponent<vue.ExtractPropTypes<{
         default: undefined;
     };
 }>> & Readonly<{}>, {
+    size: LoadingSize;
+    locale: Partial<TigerLocale>;
     className: string;
     style: Record<string, string | number>;
-    locale: Partial<TigerLocale>;
-    size: LoadingSize;
     variant: LoadingVariant;
-    text: string;
     color: LoadingColor;
-    delay: number;
-    disableTeleport: boolean;
+    text: string;
     fullscreen: boolean;
+    delay: number;
     background: string;
     customColor: string;
     lockScroll: boolean;
+    disableTeleport: boolean;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
 export { Loading, type VueLoadingProps, Loading as default };

package/dist/components/Loading.mjs

@@ -1,7 +1,7 @@
 import {
   Loading,
   Loading_default
-} from "../chunk-AUMTHL6N.mjs";
+} from "../chunk-ZOP7PEKY.mjs";
 import "../chunk-Q7Y22OFX.mjs";
 import "../chunk-UOJOJBEU.mjs";
 import "../chunk-TGXBCKOU.mjs";

package/dist/components/LoadingBar.d.mts

@@ -0,0 +1,8 @@
+import { LoadingBarApi, LoadingBarOptions } from '@expcat/tigercat-core';
+export { LoadingBarContainer, VueLoadingBarContainerProps } from './LoadingBarContainer.mjs';
+import 'vue';
+
+type VueLoadingBarProps = LoadingBarOptions;
+declare const LoadingBar: LoadingBarApi;
+
+export { LoadingBar, type VueLoadingBarProps, LoadingBar as default };

package/dist/components/LoadingBar.mjs

@@ -0,0 +1,114 @@
+import {
+  LoadingBarContainer
+} from "../chunk-TBOXTAIA.mjs";
+import {
+  getGlobalTigerLocale
+} from "../chunk-TGXBCKOU.mjs";
+
+// src/components/LoadingBar.ts
+import { createApp, defineComponent, h, ref } from "vue";
+import {
+  createLoadingBarController,
+  isBrowser,
+  LOADING_BAR_CONTAINER_ROOT_ID,
+  resolveLoadingBarMountTarget
+} from "@expcat/tigercat-core";
+var containerApp = null;
+var controller = null;
+var barState = ref(null);
+function getDefaultAriaLabel() {
+  return getGlobalTigerLocale()?.common?.loadingText;
+}
+function getController() {
+  if (!controller) {
+    controller = createLoadingBarController();
+    controller.subscribe(() => {
+      barState.value = controller?.getState() ?? null;
+    });
+  }
+  return controller;
+}
+var LoadingBarHost = /* @__PURE__ */ defineComponent({
+  name: "TigerLoadingBarHost",
+  setup() {
+    return () => {
+      const state = barState.value;
+      if (!state?.visible) return null;
+      return h(LoadingBarContainer, {
+        percentage: state.percentage,
+        status: state.status,
+        color: state.color,
+        height: state.height,
+        className: state.className,
+        style: state.style,
+        ariaLabel: state.ariaLabel
+      });
+    };
+  }
+});
+function ensureContainer(container) {
+  if (!isBrowser()) {
+    return;
+  }
+  const existingRootEl = document.getElementById(LOADING_BAR_CONTAINER_ROOT_ID);
+  if (containerApp && !existingRootEl) {
+    containerApp = null;
+  }
+  if (containerApp) {
+    return;
+  }
+  let rootEl = existingRootEl;
+  if (!rootEl) {
+    rootEl = document.createElement("div");
+    rootEl.id = LOADING_BAR_CONTAINER_ROOT_ID;
+    const mountTarget = resolveLoadingBarMountTarget(container) ?? document.body;
+    mountTarget.appendChild(rootEl);
+  }
+  containerApp = createApp(LoadingBarHost);
+  containerApp.mount(rootEl);
+}
+function teardownContainer() {
+  if (containerApp) {
+    containerApp.unmount();
+    containerApp = null;
+  }
+  if (isBrowser()) {
+    const rootEl = document.getElementById(LOADING_BAR_CONTAINER_ROOT_ID);
+    if (rootEl?.parentNode) {
+      rootEl.parentNode.removeChild(rootEl);
+    }
+  }
+}
+function withAriaLabel(options) {
+  if (options?.ariaLabel) return options;
+  const localeLabel = getDefaultAriaLabel();
+  if (!localeLabel && !options) return options;
+  return { ...options, ariaLabel: options?.ariaLabel ?? localeLabel };
+}
+var LoadingBar = {
+  start(options) {
+    const resolved = withAriaLabel(options);
+    getController().start(resolved);
+    ensureContainer(resolved?.container);
+  },
+  finish() {
+    getController().finish();
+    if (getController().getState().visible) {
+      ensureContainer();
+    }
+  },
+  error() {
+    getController().error();
+    ensureContainer();
+  },
+  clear() {
+    getController().clear();
+    teardownContainer();
+  }
+};
+var LoadingBar_default = LoadingBar;
+export {
+  LoadingBar,
+  LoadingBarContainer,
+  LoadingBar_default as default
+};