@expcat/tigercat-vue 1.0.4 → 1.1.0

package/dist/chunk-BMW2Z3G3.mjs

@@ -1,94 +0,0 @@
-import { AnchorContextKey } from './chunk-LRHJZP2C.mjs';
-import { defineComponent, inject, onMounted, onBeforeUnmount, computed, h } from 'vue';
-import { classNames, getAnchorLinkClasses, coerceClassValue } from '@expcat/tigercat-core';
-
-var AnchorLink = defineComponent({
-  name: "TigerAnchorLink",
-  inheritAttrs: false,
-  props: {
-    /**
-     * Target anchor ID (with #)
-     */
-    href: {
-      type: String,
-      required: true
-    },
-    /**
-     * Link title/text
-     */
-    title: {
-      type: String,
-      default: void 0
-    },
-    /**
-     * Link target attribute
-     */
-    target: {
-      type: String,
-      default: void 0
-    },
-    className: {
-      type: String,
-      default: void 0
-    }
-  },
-  setup(props, { slots, attrs }) {
-    const anchorContext = inject(AnchorContextKey, null);
-    onMounted(() => {
-      anchorContext?.registerLink(props.href);
-    });
-    onBeforeUnmount(() => {
-      anchorContext?.unregisterLink(props.href);
-    });
-    const handleClick = (event) => {
-      event.preventDefault();
-      anchorContext?.handleLinkClick(props.href, event);
-    };
-    const linkClasses = computed(() => {
-      const isActive = anchorContext?.activeLink === props.href;
-      return classNames(
-        getAnchorLinkClasses(isActive, props.className),
-        coerceClassValue(attrs.class)
-      );
-    });
-    return () => {
-      const slotContent = slots.default?.();
-      const hasNestedLinks = slotContent && Array.isArray(slotContent) && slotContent.some(
-        (vnode) => vnode.type && vnode.type.name === "TigerAnchorLink"
-      );
-      if (hasNestedLinks) {
-        return h("div", { class: "anchor-link-wrapper" }, [
-          h(
-            "a",
-            {
-              ...attrs,
-              href: props.href,
-              target: props.target,
-              class: linkClasses.value,
-              "data-anchor-href": props.href,
-              onClick: handleClick
-            },
-            props.title
-          ),
-          h("div", { class: "pl-3 mt-1 space-y-1" }, slotContent)
-        ]);
-      }
-      const content = slotContent ?? props.title;
-      return h(
-        "a",
-        {
-          ...attrs,
-          href: props.href,
-          target: props.target,
-          class: linkClasses.value,
-          "data-anchor-href": props.href,
-          onClick: handleClick
-        },
-        content
-      );
-    };
-  }
-});
-var AnchorLink_default = AnchorLink;
-
-export { AnchorLink, AnchorLink_default };

package/dist/chunk-BNIUWON3.js

@@ -1,243 +0,0 @@
-'use strict';
-
-var chunk5JSU44MQ_js = require('./chunk-5JSU44MQ.js');
-var vue = require('vue');
-var tigercatCore = require('@expcat/tigercat-core');
-
-var TabPane = vue.defineComponent({
-  name: "TigerTabPane",
-  props: {
-    /**
-     * Unique key for the tab pane (required)
-     */
-    tabKey: {
-      type: [String, Number],
-      required: true
-    },
-    /**
-     * Tab label/title
-     */
-    label: {
-      type: String,
-      required: true
-    },
-    /**
-     * Whether the tab is disabled
-     * @default false
-     */
-    disabled: {
-      type: Boolean,
-      default: false
-    },
-    /**
-     * Whether the tab can be closed (overrides parent closable)
-     */
-    closable: {
-      type: Boolean,
-      default: void 0
-    },
-    /**
-     * Icon for the tab
-     */
-    icon: {
-      type: [String, Object],
-      default: void 0
-    },
-    /**
-     * Additional CSS classes
-     */
-    className: {
-      type: String,
-      default: void 0
-    },
-    /**
-     * Custom styles
-     */
-    style: {
-      type: Object,
-      default: void 0
-    },
-    /**
-     * Render mode - 'tab' for tab item, 'pane' for content pane
-     * @internal
-     */
-    renderMode: {
-      type: String,
-      default: "pane"
-    },
-    // Internal props for a11y + roving tabindex
-    tabId: {
-      type: String,
-      default: void 0
-    },
-    panelId: {
-      type: String,
-      default: void 0
-    },
-    tabIndex: {
-      type: Number,
-      default: void 0
-    }
-  },
-  setup(props, { slots }) {
-    const tabsContext = vue.inject(chunk5JSU44MQ_js.TabsContextKey);
-    if (!tabsContext) {
-      throw new Error("TabPane must be used within a Tabs component");
-    }
-    const isActive = vue.computed(() => {
-      return tigercatCore.isKeyActive(props.tabKey, tabsContext.activeKey);
-    });
-    const hasBeenActivated = vue.ref(isActive.value);
-    vue.watch(isActive, (val) => {
-      if (val) hasBeenActivated.value = true;
-    });
-    const isClosable = vue.computed(() => {
-      return props.closable !== void 0 ? props.closable : tabsContext.closable && tabsContext.type === "editable-card";
-    });
-    const tabItemClasses = vue.computed(() => {
-      return tigercatCore.getTabItemClasses(isActive.value, props.disabled, tabsContext.type, tabsContext.size);
-    });
-    const tabPaneClasses = vue.computed(() => {
-      return tigercatCore.classNames(tigercatCore.getTabPaneClasses(isActive.value), props.className);
-    });
-    const handleClick = () => {
-      if (!props.disabled) {
-        tabsContext.handleTabClick(props.tabKey);
-      }
-    };
-    const handleClose = (event) => {
-      if (!props.disabled) {
-        tabsContext.handleTabClose(props.tabKey, event);
-      }
-    };
-    const handleKeydown = (event) => {
-      if (props.disabled) {
-        return;
-      }
-      if (isClosable.value && (event.key === "Backspace" || event.key === "Delete")) {
-        event.preventDefault();
-        tabsContext.handleTabClose(props.tabKey, event);
-        return;
-      }
-      const isVertical = tabsContext.tabPosition === "left" || tabsContext.tabPosition === "right";
-      const nextKeys = isVertical ? ["ArrowDown"] : ["ArrowRight"];
-      const prevKeys = isVertical ? ["ArrowUp"] : ["ArrowLeft"];
-      const key = event.key;
-      if (nextKeys.includes(key) || prevKeys.includes(key) || key === "Home" || key === "End" || key === "Enter" || key === " ") {
-        event.preventDefault();
-      }
-      if (key === "Enter" || key === " ") {
-        tabsContext.handleTabClick(props.tabKey);
-        return;
-      }
-      const tabList = event.currentTarget?.closest('[role="tablist"]');
-      const tabButtons = Array.from(
-        tabList?.querySelectorAll('[role="tab"]') ?? []
-      );
-      const enabled = tabButtons.filter((b) => !b.disabled);
-      const currentIndex = enabled.findIndex((b) => b.id === props.tabId);
-      if (currentIndex === -1) {
-        return;
-      }
-      const focusByIndex = (index) => {
-        const next = enabled[index];
-        if (!next) return;
-        next.focus();
-        const nextKey = next.getAttribute("data-tiger-tab-key");
-        if (nextKey != null) {
-          const parsed = nextKey.startsWith("n:") ? Number(nextKey.slice(2)) : nextKey.startsWith("s:") ? nextKey.slice(2) : nextKey;
-          tabsContext.handleTabClick(parsed);
-        }
-      };
-      if (nextKeys.includes(key)) {
-        focusByIndex((currentIndex + 1) % enabled.length);
-        return;
-      }
-      if (prevKeys.includes(key)) {
-        focusByIndex((currentIndex - 1 + enabled.length) % enabled.length);
-        return;
-      }
-      if (key === "Home") {
-        focusByIndex(0);
-        return;
-      }
-      if (key === "End") {
-        focusByIndex(enabled.length - 1);
-      }
-    };
-    return () => {
-      if (props.renderMode === "tab") {
-        return vue.h(
-          "button",
-          {
-            type: "button",
-            class: tabItemClasses.value,
-            role: "tab",
-            id: props.tabId,
-            "aria-controls": props.panelId,
-            "aria-selected": isActive.value,
-            "aria-disabled": props.disabled,
-            disabled: props.disabled,
-            tabindex: typeof props.tabIndex === "number" ? props.tabIndex : isActive.value ? 0 : -1,
-            "data-tiger-tabs-id": tabsContext.idBase,
-            "data-tiger-tab-key": typeof props.tabKey === "number" ? `n:${props.tabKey}` : `s:${props.tabKey}`,
-            onClick: handleClick,
-            onKeydown: handleKeydown
-          },
-          [
-            // Icon
-            props.icon && vue.h("span", { class: "flex items-center" }, props.icon),
-            // Label
-            vue.h("span", props.label),
-            // Close button
-            isClosable.value && vue.h(
-              "span",
-              {
-                role: "button",
-                class: tigercatCore.tabCloseButtonClasses,
-                "aria-label": `Close ${String(props.label)}`,
-                tabindex: -1,
-                onClick: handleClose
-              },
-              vue.h(
-                "svg",
-                {
-                  class: "w-4 h-4",
-                  fill: "none",
-                  stroke: "currentColor",
-                  viewBox: tigercatCore.closeIconViewBox
-                },
-                vue.h("path", {
-                  "stroke-linecap": "round",
-                  "stroke-linejoin": "round",
-                  "stroke-width": "2",
-                  d: tigercatCore.closeIconPathD
-                })
-              )
-            )
-          ]
-        );
-      }
-      const shouldRender = tabsContext.lazy ? hasBeenActivated.value && (isActive.value || !tabsContext.destroyInactiveTabPane) : isActive.value || !tabsContext.destroyInactiveTabPane;
-      if (!shouldRender) {
-        return null;
-      }
-      return vue.h(
-        "div",
-        {
-          class: tabPaneClasses.value,
-          style: props.style,
-          role: "tabpanel",
-          id: props.panelId,
-          "aria-labelledby": props.tabId,
-          "aria-hidden": !isActive.value
-        },
-        slots.default?.()
-      );
-    };
-  }
-});
-var TabPane_default = TabPane;
-
-exports.TabPane = TabPane;
-exports.TabPane_default = TabPane_default;

package/dist/chunk-CG3AMK5U.mjs

@@ -1,38 +0,0 @@
-import { defineComponent, computed, h } from 'vue';
-import { formatStatisticValue, classNames, statisticBaseClasses, coerceClassValue, getStatisticTitleClasses, getStatisticValueClasses, statisticPrefixClasses, statisticSuffixClasses } from '@expcat/tigercat-core';
-
-// src/components/Statistic.ts
-var Statistic = defineComponent({
-  name: "TigerStatistic",
-  props: {
-    title: { type: String, default: void 0 },
-    value: { type: [String, Number], default: void 0 },
-    precision: { type: Number, default: void 0 },
-    prefix: { type: String, default: void 0 },
-    suffix: { type: String, default: void 0 },
-    groupSeparator: { type: Boolean, default: false },
-    size: { type: String, default: "md" }
-  },
-  setup(props, { attrs }) {
-    const formatted = computed(
-      () => formatStatisticValue(props.value, props.precision, props.groupSeparator)
-    );
-    return () => h(
-      "div",
-      {
-        class: classNames(statisticBaseClasses, coerceClassValue(attrs.class))
-      },
-      [
-        props.title ? h("div", { class: getStatisticTitleClasses(props.size) }, props.title) : null,
-        h("div", { class: getStatisticValueClasses(props.size) }, [
-          props.prefix ? h("span", { class: statisticPrefixClasses }, props.prefix) : null,
-          h("span", null, formatted.value),
-          props.suffix ? h("span", { class: statisticSuffixClasses }, props.suffix) : null
-        ])
-      ]
-    );
-  }
-});
-var Statistic_default = Statistic;
-
-export { Statistic, Statistic_default };

package/dist/chunk-CXJUEG75.js

@@ -1,331 +0,0 @@
-'use strict';
-
-var chunkV4PBWEAU_js = require('./chunk-V4PBWEAU.js');
-var vue = require('vue');
-var tigercatCore = require('@expcat/tigercat-core');
-
-var Kanban = vue.defineComponent({
-  name: "TigerKanban",
-  inheritAttrs: false,
-  props: {
-    columns: {
-      type: Array,
-      default: void 0
-    },
-    defaultColumns: {
-      type: Array,
-      default: () => []
-    },
-    draggable: { type: Boolean, default: true },
-    columnDraggable: { type: Boolean, default: true },
-    enforceWipLimit: { type: Boolean, default: false },
-    beforeCardMove: {
-      type: Function,
-      default: void 0
-    },
-    beforeColumnMove: {
-      type: Function,
-      default: void 0
-    },
-    onCardAdd: {
-      type: Function,
-      default: void 0
-    },
-    filterText: { type: String, default: "" },
-    hiddenColumns: {
-      type: Array,
-      default: () => []
-    },
-    showCardCount: { type: Boolean, default: true },
-    allowAddCard: { type: Boolean, default: true },
-    allowAddColumn: { type: Boolean, default: false },
-    locale: {
-      type: Object,
-      default: void 0
-    },
-    className: { type: String, default: void 0 },
-    style: {
-      type: Object,
-      default: void 0
-    }
-  },
-  emits: ["card-move", "column-move", "update:columns", "card-add", "column-add"],
-  setup(props, { emit, attrs, slots }) {
-    const config = chunkV4PBWEAU_js.useTigerConfig();
-    const boardRef = vue.ref(null);
-    const internalColumns = vue.ref(props.defaultColumns ?? []);
-    const isControlled = vue.computed(() => props.columns !== void 0);
-    const rawColumns = vue.computed(() => isControlled.value ? props.columns : internalColumns.value);
-    const visibleColumns = vue.computed(
-      () => tigercatCore.filterColumns(rawColumns.value, props.filterText || "", props.hiddenColumns)
-    );
-    vue.watch(
-      () => props.columns,
-      (v) => {
-        if (v) internalColumns.value = v;
-      }
-    );
-    function updateColumns(cols) {
-      if (!isControlled.value) internalColumns.value = cols;
-      emit("update:columns", cols);
-    }
-    const merged = vue.computed(() => tigercatCore.mergeTigerLocale(config.value.locale, props.locale));
-    const labels = vue.computed(() => tigercatCore.getTaskBoardLabels(merged.value));
-    const dragState = vue.ref(null);
-    const dropTargetCol = vue.ref(null);
-    const dropTargetIdx = vue.ref(-1);
-    const dragType = vue.computed(() => dragState.value?.type ?? null);
-    function onCardDragStart(e, card, colId, idx) {
-      if (!props.draggable || !e.dataTransfer) return;
-      tigercatCore.setDragData(e.dataTransfer, tigercatCore.createCardDragData(card.id, colId, idx));
-      dragState.value = { type: "card", id: card.id, fromColumnId: colId, fromIndex: idx };
-    }
-    function onColumnDragStart(e, colId, idx) {
-      if (!props.columnDraggable || !e.dataTransfer) return;
-      tigercatCore.setDragData(e.dataTransfer, tigercatCore.createColumnDragData(colId, idx));
-      dragState.value = { type: "column", id: colId, fromIndex: idx };
-    }
-    function onDragOver(e, colId) {
-      e.preventDefault();
-      if (!dragState.value) return;
-      dropTargetCol.value = colId;
-      if (dragState.value.type === "card") {
-        const colEl = e.currentTarget.querySelector("[data-kanban-body]");
-        if (colEl) {
-          const cards = Array.from(colEl.querySelectorAll("[data-kanban-card]"));
-          const rects = cards.map((c) => c.getBoundingClientRect());
-          dropTargetIdx.value = tigercatCore.getDropIndex(e.clientY, rects);
-        }
-      }
-    }
-    function onColumnDragOver(e) {
-      e.preventDefault();
-      if (!dragState.value || dragState.value.type !== "column") return;
-      const boardEl = boardRef.value;
-      if (!boardEl) return;
-      const cols = Array.from(boardEl.querySelectorAll("[data-kanban-column]"));
-      const rects = cols.map((c) => c.getBoundingClientRect());
-      dropTargetIdx.value = tigercatCore.getColumnDropIndex(e.clientX, rects);
-    }
-    async function onDrop(e) {
-      e.preventDefault();
-      if (!dragState.value || !e.dataTransfer) return;
-      const data = tigercatCore.parseDragData(e.dataTransfer);
-      if (!data) return;
-      const cols = rawColumns.value;
-      if (data.type === "card" && dropTargetCol.value != null) {
-        if (props.beforeCardMove) {
-          const evt = {
-            cardId: data.cardId,
-            fromColumnId: data.columnId,
-            toColumnId: dropTargetCol.value,
-            fromIndex: data.index,
-            toIndex: dropTargetIdx.value
-          };
-          const ok = await props.beforeCardMove(evt);
-          if (!ok) {
-            resetDrag();
-            return;
-          }
-        }
-        const result = tigercatCore.moveCard(
-          cols,
-          data.cardId,
-          data.columnId,
-          dropTargetCol.value,
-          dropTargetIdx.value,
-          { enforceWipLimit: props.enforceWipLimit }
-        );
-        if (result) {
-          updateColumns(result.columns);
-          emit("card-move", result.event);
-        }
-      } else if (data.type === "column") {
-        if (props.beforeColumnMove) {
-          const evt = {
-            columnId: data.columnId,
-            fromIndex: data.index,
-            toIndex: dropTargetIdx.value
-          };
-          const ok = await props.beforeColumnMove(evt);
-          if (!ok) {
-            resetDrag();
-            return;
-          }
-        }
-        const result = tigercatCore.reorderColumns(cols, data.index, dropTargetIdx.value);
-        if (result) {
-          updateColumns(result.columns);
-          emit("column-move", result.event);
-        }
-      }
-      resetDrag();
-    }
-    function onDragEnd() {
-      resetDrag();
-    }
-    function resetDrag() {
-      dragState.value = null;
-      dropTargetCol.value = null;
-      dropTargetIdx.value = -1;
-    }
-    const containerClasses = vue.computed(
-      () => tigercatCore.classNames(tigercatCore.getKanbanContainerClasses(props.className), tigercatCore.coerceClassValue(attrs.class))
-    );
-    const containerStyle = vue.computed(() => tigercatCore.mergeStyleValues(attrs.style, props.style));
-    return () => {
-      const children = visibleColumns.value.map((col, colIdx) => {
-        const wipExceeded = tigercatCore.isWipExceeded(col);
-        const cardCount = tigercatCore.getColumnCardCount(col);
-        const isDragOverCol = dropTargetCol.value === col.id;
-        const isColDragging = dragState.value?.type === "column" && dragState.value.id === col.id;
-        const headerContent = [
-          slots["column-header"] ? slots["column-header"]({ column: col }) : vue.h("span", {}, tigercatCore.resolveLocaleText(col.title)),
-          props.showCardCount ? vue.h(
-            "span",
-            {
-              class: tigercatCore.classNames(
-                tigercatCore.kanbanCardCountClasses,
-                wipExceeded && tigercatCore.taskBoardWipExceededClasses
-              )
-            },
-            cardCount.limit ? `${cardCount.count}/${cardCount.limit}` : `${cardCount.count}`
-          ) : null
-        ];
-        const header = vue.h(
-          "div",
-          {
-            class: tigercatCore.classNames(
-              tigercatCore.taskBoardColumnHeaderClasses,
-              wipExceeded && tigercatCore.taskBoardWipExceededClasses
-            )
-          },
-          headerContent
-        );
-        const cardEls = col.cards.map((card, cardIdx) => {
-          const isCardDragging = dragState.value?.type === "card" && dragState.value.id === card.id;
-          return vue.h(
-            "div",
-            {
-              key: card.id,
-              class: tigercatCore.classNames(
-                tigercatCore.taskBoardCardClasses,
-                isCardDragging && tigercatCore.taskBoardCardDraggingClasses
-              ),
-              draggable: props.draggable,
-              "data-kanban-card": "",
-              onDragstart: (e) => onCardDragStart(e, card, col.id, cardIdx)
-            },
-            slots.card ? slots.card({ card, columnId: col.id }) : [
-              vue.h("div", { class: "font-medium text-sm" }, tigercatCore.resolveLocaleText(card.title)),
-              card.description ? vue.h(
-                "div",
-                { class: "text-xs text-[var(--tiger-text-muted,#6b7280)] mt-1" },
-                card.description
-              ) : null
-            ]
-          );
-        });
-        if (isDragOverCol && dragType.value === "card" && dropTargetIdx.value >= 0) {
-          cardEls.splice(
-            dropTargetIdx.value,
-            0,
-            vue.h("div", {
-              key: "__drop-indicator",
-              class: tigercatCore.taskBoardDropIndicatorClasses
-            })
-          );
-        }
-        const body = vue.h(
-          "div",
-          {
-            class: tigercatCore.taskBoardColumnBodyClasses,
-            "data-kanban-body": ""
-          },
-          cardEls.length > 0 ? cardEls : [
-            vue.h(
-              "div",
-              { class: tigercatCore.taskBoardEmptyClasses },
-              tigercatCore.resolveLocaleText(labels.value.emptyColumnText)
-            )
-          ]
-        );
-        const addBtn = props.allowAddCard ? vue.h(
-          "div",
-          {
-            class: tigercatCore.kanbanAddCardClasses,
-            role: "button",
-            tabindex: 0,
-            onClick: () => {
-              props.onCardAdd?.(col.id);
-              emit("card-add", col.id);
-            },
-            onKeydown: (e) => {
-              if (e.key === "Enter" || e.key === " ") {
-                e.preventDefault();
-                props.onCardAdd?.(col.id);
-                emit("card-add", col.id);
-              }
-            }
-          },
-          "+ " + tigercatCore.resolveLocaleText(labels.value.addCardText)
-        ) : null;
-        return vue.h(
-          "div",
-          {
-            key: col.id,
-            class: tigercatCore.classNames(
-              tigercatCore.taskBoardColumnClasses,
-              isDragOverCol && dragType.value === "card" && tigercatCore.taskBoardColumnDropTargetClasses,
-              isColDragging && tigercatCore.taskBoardColumnDraggingClasses
-            ),
-            "data-kanban-column": "",
-            draggable: props.columnDraggable,
-            onDragstart: (e) => onColumnDragStart(e, col.id, colIdx),
-            onDragover: (e) => onDragOver(e, col.id),
-            onDrop,
-            onDragend: onDragEnd
-          },
-          [header, body, addBtn]
-        );
-      });
-      if (props.allowAddColumn) {
-        children.push(
-          vue.h(
-            "div",
-            {
-              key: "__add-column",
-              class: tigercatCore.kanbanAddColumnClasses,
-              role: "button",
-              tabindex: 0,
-              onClick: () => emit("column-add"),
-              onKeydown: (e) => {
-                if (e.key === "Enter" || e.key === " ") {
-                  e.preventDefault();
-                  emit("column-add");
-                }
-              }
-            },
-            "+ " + tigercatCore.resolveLocaleText(labels.value.addCardText)
-          )
-        );
-      }
-      return vue.h(
-        "div",
-        {
-          ref: boardRef,
-          class: containerClasses.value,
-          style: containerStyle.value,
-          role: "region",
-          "aria-label": "Kanban board",
-          onDragover: onColumnDragOver
-        },
-        children
-      );
-    };
-  }
-});
-var Kanban_default = Kanban;
-
-exports.Kanban = Kanban;
-exports.Kanban_default = Kanban_default;