@expcat/tigercat-vue 2.1.2 → 2.1.3

package/dist/chunk-W2ICYZVU.mjs

@@ -1,286 +0,0 @@
-import {
-  useFloatingPopup
-} from "./chunk-PMQSXEMT.mjs";
-import {
-  renderVueOverlayTeleport
-} from "./chunk-Q7Y22OFX.mjs";
-
-// src/components/Popconfirm.ts
-import { defineComponent, computed, h, cloneVNode, isVNode } from "vue";
-import {
-  classNames,
-  coerceClassValue,
-  createFloatingIdFactory,
-  getPopconfirmIconPath,
-  getPopconfirmContainerClasses,
-  getPopconfirmTriggerClasses,
-  getPopconfirmContentClasses,
-  getPopconfirmTitleClasses,
-  getPopconfirmDescriptionClasses,
-  getPopconfirmIconClasses,
-  getPopconfirmArrowClasses,
-  getPopconfirmButtonsClasses,
-  getPopconfirmCancelButtonClasses,
-  getPopconfirmOkButtonClasses,
-  mergeStyleValues,
-  popconfirmIconPathStrokeLinecap,
-  popconfirmIconPathStrokeLinejoin,
-  popconfirmIconStrokeWidth,
-  popconfirmIconViewBox
-} from "@expcat/tigercat-core";
-var renderPopconfirmIcon = (iconType) => {
-  return h(
-    "svg",
-    {
-      xmlns: "http://www.w3.org/2000/svg",
-      fill: "none",
-      viewBox: popconfirmIconViewBox,
-      "stroke-width": String(popconfirmIconStrokeWidth),
-      stroke: "currentColor"
-    },
-    [
-      h("path", {
-        "stroke-linecap": popconfirmIconPathStrokeLinecap,
-        "stroke-linejoin": popconfirmIconPathStrokeLinejoin,
-        d: getPopconfirmIconPath(iconType)
-      })
-    ]
-  );
-};
-var createPopconfirmId = createFloatingIdFactory("popconfirm");
-var Popconfirm = defineComponent({
-  name: "TigerPopconfirm",
-  inheritAttrs: false,
-  props: {
-    /** 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 */
-    description: { type: String, default: void 0 },
-    /** Icon type to display @default 'warning' */
-    icon: {
-      type: String,
-      default: "warning"
-    },
-    /** Whether to show icon @default true */
-    showIcon: { type: Boolean, default: true },
-    /** Confirm button text @default '确定' */
-    okText: { type: String, default: "\u786E\u5B9A" },
-    /** Cancel button text @default '取消' */
-    cancelText: { type: String, default: "\u53D6\u6D88" },
-    /** Confirm button type @default 'primary' */
-    okType: { type: String, default: "primary" },
-    /** Placement @default 'top' */
-    placement: { type: String, default: "top" },
-    /** Offset in pixels @default 8 */
-    offset: { type: Number, default: 8 },
-    /** Disabled state @default false */
-    disabled: { type: Boolean, default: false },
-    /** Additional CSS classes */
-    className: { type: String, default: void 0 },
-    style: { type: [String, Object, Array], default: void 0 }
-  },
-  emits: ["update:open", "open-change", "confirm", "cancel"],
-  setup(props, { slots, emit, attrs }) {
-    const {
-      currentVisible,
-      setVisible,
-      containerRef,
-      triggerRef,
-      floatingRef,
-      closeAndRestoreFocus,
-      floatingStyles,
-      floatingClasses,
-      positioned,
-      overlayTarget,
-      actualPlacement
-    } = useFloatingPopup({ props, emit, multiTrigger: false });
-    const popconfirmId = createPopconfirmId();
-    const titleId = `${popconfirmId}-title`;
-    const descriptionId = `${popconfirmId}-description`;
-    const handleConfirm = () => {
-      emit("confirm");
-      closeAndRestoreFocus();
-    };
-    const handleCancel = () => {
-      emit("cancel");
-      closeAndRestoreFocus();
-    };
-    const handleTriggerClick = () => {
-      if (props.disabled) return;
-      setVisible(!currentVisible.value);
-    };
-    const containerClasses = computed(() => {
-      return classNames(
-        getPopconfirmContainerClasses(),
-        props.className,
-        coerceClassValue(attrs.class)
-      );
-    });
-    const triggerClasses = computed(() => getPopconfirmTriggerClasses(props.disabled));
-    const arrowClasses = computed(() => getPopconfirmArrowClasses(actualPlacement.value));
-    const contentClasses = getPopconfirmContentClasses();
-    const titleClasses = getPopconfirmTitleClasses();
-    const descriptionClasses = getPopconfirmDescriptionClasses();
-    const buttonsClasses = getPopconfirmButtonsClasses();
-    const cancelButtonClasses = getPopconfirmCancelButtonClasses();
-    const iconClasses = computed(() => getPopconfirmIconClasses(props.icon));
-    const okButtonClasses = computed(() => getPopconfirmOkButtonClasses(props.okType));
-    return () => {
-      const useTriggerSlot = Boolean(slots.trigger);
-      const defaultSlot = useTriggerSlot ? slots.trigger({ open: currentVisible.value }) : slots.default?.();
-      if (!defaultSlot || defaultSlot.length === 0) return null;
-      const {
-        class: _class,
-        style: _style,
-        ...restAttrs
-      } = attrs;
-      const triggerA11yProps = {
-        "aria-haspopup": "dialog",
-        "aria-expanded": Boolean(currentVisible.value),
-        "aria-controls": currentVisible.value ? popconfirmId : void 0,
-        "aria-disabled": props.disabled ? "true" : void 0,
-        "data-state": currentVisible.value ? "open" : "closed"
-      };
-      const trigger = (() => {
-        if (!useTriggerSlot && defaultSlot.length === 1) {
-          const only = defaultSlot[0];
-          if (isVNode(only)) {
-            const existingProps = only.props ?? {};
-            const existingOnClick = existingProps.onClick;
-            const onClick = (event) => {
-              if (typeof existingOnClick === "function") {
-                ;
-                existingOnClick(event);
-              } else if (Array.isArray(existingOnClick)) {
-                for (const handler of existingOnClick) {
-                  if (typeof handler === "function") {
-                    ;
-                    handler(event);
-                  }
-                }
-              }
-              if (event.defaultPrevented) return;
-              handleTriggerClick();
-            };
-            return h(
-              "div",
-              {
-                ref: triggerRef,
-                class: "inline-block"
-              },
-              [
-                cloneVNode(
-                  only,
-                  {
-                    ...triggerA11yProps,
-                    class: classNames(coerceClassValue(existingProps.class), triggerClasses.value),
-                    onClick
-                  },
-                  true
-                )
-              ]
-            );
-          }
-        }
-        return h(
-          "div",
-          {
-            ref: triggerRef,
-            class: triggerClasses.value,
-            onClick: handleTriggerClick,
-            role: "button",
-            tabindex: props.disabled ? -1 : 0,
-            onKeydown: (event) => {
-              if (props.disabled) return;
-              if (event.key === "Enter" || event.key === " ") {
-                event.preventDefault();
-                handleTriggerClick();
-              }
-            },
-            ...triggerA11yProps
-          },
-          defaultSlot
-        );
-      })();
-      const hasDescription = Boolean(props.description || slots.description);
-      const content = h(
-        "div",
-        {
-          ref: floatingRef,
-          class: floatingClasses.value,
-          style: floatingStyles.value,
-          "data-positioned": positioned.value,
-          hidden: !currentVisible.value,
-          "aria-hidden": !currentVisible.value
-        },
-        [
-          h("div", { class: "relative" }, [
-            h("div", { class: arrowClasses.value, "aria-hidden": "true" }),
-            h(
-              "div",
-              {
-                id: popconfirmId,
-                role: "dialog",
-                "aria-modal": "false",
-                "aria-labelledby": titleId,
-                "aria-describedby": hasDescription ? descriptionId : void 0,
-                class: contentClasses
-              },
-              [
-                // Title section with icon
-                h("div", { class: "flex items-start" }, [
-                  props.showIcon && h(
-                    "div",
-                    { class: iconClasses.value, "aria-hidden": "true" },
-                    renderPopconfirmIcon(props.icon)
-                  ),
-                  h("div", { class: "flex-1" }, [
-                    slots.title ? h("div", { id: titleId, class: titleClasses }, slots.title()) : h("div", { id: titleId, class: titleClasses }, props.title),
-                    hasDescription && h(
-                      "div",
-                      { id: descriptionId, class: descriptionClasses },
-                      slots.description ? slots.description() : props.description
-                    )
-                  ])
-                ]),
-                // Buttons
-                h("div", { class: buttonsClasses }, [
-                  h(
-                    "button",
-                    { type: "button", class: cancelButtonClasses, onClick: handleCancel },
-                    props.cancelText
-                  ),
-                  h(
-                    "button",
-                    { type: "button", class: okButtonClasses.value, onClick: handleConfirm },
-                    props.okText
-                  )
-                ])
-              ]
-            )
-          ])
-        ]
-      );
-      return h(
-        "div",
-        {
-          ...restAttrs,
-          ref: containerRef,
-          class: containerClasses.value,
-          style: mergeStyleValues(attrs.style, props.style)
-        },
-        [trigger, renderVueOverlayTeleport(content, overlayTarget.value)]
-      );
-    };
-  }
-});
-var Popconfirm_default = Popconfirm;
-
-export {
-  Popconfirm,
-  Popconfirm_default
-};

package/dist/chunk-W3QOMJKQ.mjs

@@ -1,322 +0,0 @@
-import {
-  useChartInteraction
-} from "./chunk-FHUGOSEY.mjs";
-import {
-  ChartTooltip
-} from "./chunk-SPFL55TF.mjs";
-import {
-  ChartCanvas
-} from "./chunk-SNNT64HK.mjs";
-
-// src/components/HeatmapChart.ts
-import { defineComponent, computed, h, nextTick, ref, watchEffect } from "vue";
-import {
-  classNames,
-  computeHeatmapCells,
-  getHeatmapCellIndexAtPoint,
-  getChartElementOpacity,
-  getChartInnerRect,
-  resolveHeatmapRenderMode,
-  resolveChartTooltipContent,
-  chartAxisTickTextClasses
-} from "@expcat/tigercat-core";
-var HeatmapChart = defineComponent({
-  name: "TigerHeatmapChart",
-  props: {
-    width: { type: Number, default: 400 },
-    height: { type: Number, default: 300 },
-    padding: { type: [Number, Object], default: 40 },
-    data: { type: Array, required: true },
-    xLabels: { type: Array, required: true },
-    yLabels: { type: Array, required: true },
-    minColor: { type: String, default: "#f0f9ff" },
-    maxColor: { type: String, default: "#2563eb" },
-    colorSpace: { type: String, default: "rgb" },
-    cellRadius: { type: Number, default: 2 },
-    cellGap: { type: Number, default: 1 },
-    showValues: { type: Boolean, default: false },
-    renderMode: { type: String, default: "auto" },
-    canvasThreshold: { type: Number },
-    valueFormatter: { type: Function },
-    // Interaction
-    hoverable: { type: Boolean, default: false },
-    hoveredIndex: { type: Number, default: void 0 },
-    activeOpacity: { type: Number, default: 1 },
-    inactiveOpacity: { type: Number, default: 0.25 },
-    selectable: { type: Boolean, default: false },
-    selectedIndex: { type: Number, default: void 0 },
-    // Tooltip
-    showTooltip: { type: Boolean, default: true },
-    tooltipFormatter: {
-      type: Function
-    },
-    // a11y
-    title: { type: String },
-    desc: { type: String },
-    className: { type: String }
-  },
-  emits: ["update:hoveredIndex", "update:selectedIndex", "cell-click", "cell-hover"],
-  setup(props, { emit }) {
-    const canvasRef = ref(null);
-    const {
-      tooltipPosition,
-      resolvedHoveredIndex,
-      activeIndex,
-      handleMouseEnter,
-      handleMouseMove,
-      handleMouseLeave,
-      handleClick,
-      wrapperClasses: _wrapperClasses
-    } = useChartInteraction({
-      hoverable: computed(() => props.hoverable),
-      showTooltip: computed(() => props.showTooltip),
-      hoveredIndexProp: () => props.hoveredIndex,
-      selectable: computed(() => props.selectable),
-      selectedIndexProp: () => props.selectedIndex,
-      activeOpacity: computed(() => props.activeOpacity),
-      inactiveOpacity: computed(() => props.inactiveOpacity),
-      emit,
-      getData: (index) => props.data[index],
-      eventNames: { hover: "cell-hover", click: "cell-click" }
-    });
-    const innerRect = computed(() => getChartInnerRect(props.width, props.height, props.padding));
-    const cells = computed(
-      () => computeHeatmapCells(props.data, {
-        xLabels: props.xLabels,
-        yLabels: props.yLabels,
-        width: innerRect.value.width,
-        height: innerRect.value.height,
-        cellGap: props.cellGap,
-        minColor: props.minColor,
-        maxColor: props.maxColor,
-        colorSpace: props.colorSpace
-      })
-    );
-    const tooltipContent = computed(
-      () => resolveChartTooltipContent(resolvedHoveredIndex.value, cells.value, void 0, (cell) => {
-        const val = props.valueFormatter ? props.valueFormatter(cell.value) : `${cell.value}`;
-        return `${cell.xLabel} \xD7 ${cell.yLabel}: ${val}`;
-      })
-    );
-    const resolvedRenderMode = computed(
-      () => resolveHeatmapRenderMode(cells.value.length, {
-        renderMode: props.renderMode,
-        canvasThreshold: props.canvasThreshold
-      })
-    );
-    const shouldRenderCanvas = computed(() => resolvedRenderMode.value === "canvas");
-    watchEffect(() => {
-      if (!shouldRenderCanvas.value) return;
-      const rect = innerRect.value;
-      const cellList = cells.value;
-      const currentActiveIndex = activeIndex.value;
-      const currentActiveOpacity = props.activeOpacity;
-      const currentInactiveOpacity = props.inactiveOpacity;
-      const currentCellRadius = props.cellRadius;
-      const currentShowValues = props.showValues;
-      const formatter = props.valueFormatter;
-      nextTick(() => {
-        const canvas = canvasRef.value;
-        const context = canvas?.getContext("2d");
-        if (!canvas || !context) return;
-        context.clearRect(0, 0, rect.width, rect.height);
-        context.textAlign = "center";
-        context.textBaseline = "middle";
-        context.font = "10px sans-serif";
-        cellList.forEach((cell, idx) => {
-          context.globalAlpha = getChartElementOpacity(idx, currentActiveIndex, {
-            activeOpacity: currentActiveOpacity,
-            inactiveOpacity: currentInactiveOpacity
-          }) ?? 1;
-          context.fillStyle = cell.fill;
-          const radius = Math.max(0, Math.min(currentCellRadius, cell.w / 2, cell.h / 2));
-          if (radius > 0) {
-            context.beginPath();
-            context.moveTo(cell.x + radius, cell.y);
-            context.lineTo(cell.x + cell.w - radius, cell.y);
-            context.quadraticCurveTo(cell.x + cell.w, cell.y, cell.x + cell.w, cell.y + radius);
-            context.lineTo(cell.x + cell.w, cell.y + cell.h - radius);
-            context.quadraticCurveTo(
-              cell.x + cell.w,
-              cell.y + cell.h,
-              cell.x + cell.w - radius,
-              cell.y + cell.h
-            );
-            context.lineTo(cell.x + radius, cell.y + cell.h);
-            context.quadraticCurveTo(cell.x, cell.y + cell.h, cell.x, cell.y + cell.h - radius);
-            context.lineTo(cell.x, cell.y + radius);
-            context.quadraticCurveTo(cell.x, cell.y, cell.x + radius, cell.y);
-            context.closePath();
-            context.fill();
-          } else {
-            context.fillRect(cell.x, cell.y, cell.w, cell.h);
-          }
-          if (currentShowValues) {
-            context.globalAlpha = 1;
-            context.fillStyle = "var(--tiger-text,#374151)";
-            context.fillText(
-              formatter ? formatter(cell.value) : `${cell.value}`,
-              cell.x + cell.w / 2,
-              cell.y + cell.h / 2
-            );
-          }
-        });
-        context.globalAlpha = 1;
-      });
-    });
-    const getCanvasPoint = (event) => {
-      const canvas = event.currentTarget;
-      const bounds = canvas.getBoundingClientRect();
-      const scaleX = bounds.width > 0 ? canvas.width / bounds.width : 1;
-      const scaleY = bounds.height > 0 ? canvas.height / bounds.height : 1;
-      return {
-        x: event.offsetX * scaleX,
-        y: event.offsetY * scaleY
-      };
-    };
-    const handleCanvasMouseMove = (event) => {
-      const point = getCanvasPoint(event);
-      const index = getHeatmapCellIndexAtPoint(cells.value, point.x, point.y);
-      if (index === null) {
-        handleMouseLeave();
-        return;
-      }
-      handleMouseEnter(index, event);
-      handleMouseMove(event);
-    };
-    const handleCanvasClick = (event) => {
-      const point = getCanvasPoint(event);
-      const index = getHeatmapCellIndexAtPoint(cells.value, point.x, point.y);
-      if (index !== null) {
-        handleClick(index);
-      }
-    };
-    return () => {
-      const interactive = props.hoverable || props.selectable;
-      const pointerInteractive = interactive || props.showTooltip;
-      const rect = innerRect.value;
-      const chart = h(
-        ChartCanvas,
-        {
-          width: props.width,
-          height: props.height,
-          padding: props.padding,
-          title: props.title,
-          desc: props.desc,
-          className: classNames(props.className)
-        },
-        {
-          default: () => {
-            const xAxisLabels = props.xLabels.map((label, i) => {
-              const cellW = (rect.width - props.cellGap * (props.xLabels.length - 1)) / props.xLabels.length;
-              return h(
-                "text",
-                {
-                  key: `x-${i}`,
-                  x: i * (cellW + props.cellGap) + cellW / 2,
-                  y: rect.height + 16,
-                  class: chartAxisTickTextClasses,
-                  "text-anchor": "middle"
-                },
-                label
-              );
-            });
-            const yAxisLabels = props.yLabels.map((label, i) => {
-              const cellH = (rect.height - props.cellGap * (props.yLabels.length - 1)) / props.yLabels.length;
-              return h(
-                "text",
-                {
-                  key: `y-${i}`,
-                  x: -8,
-                  y: i * (cellH + props.cellGap) + cellH / 2,
-                  class: chartAxisTickTextClasses,
-                  "text-anchor": "end",
-                  "dominant-baseline": "middle"
-                },
-                label
-              );
-            });
-            const cellElems = shouldRenderCanvas.value ? [] : cells.value.map((cell, idx) => {
-              const opacity = getChartElementOpacity(idx, activeIndex.value, {
-                activeOpacity: props.activeOpacity,
-                inactiveOpacity: props.inactiveOpacity
-              });
-              const elems = [
-                h("rect", {
-                  key: `cell-${idx}`,
-                  x: cell.x,
-                  y: cell.y,
-                  width: cell.w,
-                  height: cell.h,
-                  rx: props.cellRadius,
-                  fill: cell.fill,
-                  opacity,
-                  class: classNames(interactive && "cursor-pointer"),
-                  style: {
-                    transition: "opacity var(--tiger-motion-duration-base,0.2s) var(--tiger-motion-ease-decelerate,ease-out)",
-                    rx: `var(--tiger-chart-block-radius, ${props.cellRadius}px)`
-                  },
-                  onMouseenter: (e) => handleMouseEnter(idx, e),
-                  onMousemove: handleMouseMove,
-                  onMouseleave: handleMouseLeave,
-                  onClick: () => handleClick(idx)
-                })
-              ];
-              if (props.showValues) {
-                const val = props.valueFormatter ? props.valueFormatter(cell.value) : `${cell.value}`;
-                elems.push(
-                  h(
-                    "text",
-                    {
-                      key: `val-${idx}`,
-                      x: cell.x + cell.w / 2,
-                      y: cell.y + cell.h / 2,
-                      class: "fill-[color:var(--tiger-text,#374151)] text-[10px]",
-                      "text-anchor": "middle",
-                      "dominant-baseline": "middle"
-                    },
-                    val
-                  )
-                );
-              }
-              return elems;
-            }).flat();
-            return [...xAxisLabels, ...yAxisLabels, ...cellElems];
-          }
-        }
-      );
-      const tooltip = props.showTooltip ? h(ChartTooltip, {
-        content: tooltipContent.value,
-        open: resolvedHoveredIndex.value !== null && tooltipContent.value !== "",
-        x: tooltipPosition.value.x,
-        y: tooltipPosition.value.y
-      }) : null;
-      const canvas = shouldRenderCanvas.value ? h("canvas", {
-        ref: canvasRef,
-        width: rect.width,
-        height: rect.height,
-        class: classNames(interactive && "cursor-pointer"),
-        style: {
-          position: "absolute",
-          left: `${rect.x}px`,
-          top: `${rect.y}px`,
-          width: `${rect.width}px`,
-          height: `${rect.height}px`,
-          pointerEvents: pointerInteractive ? "auto" : "none"
-        },
-        "data-heatmap-canvas": "true",
-        "data-heatmap-render-mode": resolvedRenderMode.value,
-        onMousemove: pointerInteractive ? handleCanvasMouseMove : void 0,
-        onMouseleave: pointerInteractive ? handleMouseLeave : void 0,
-        onClick: interactive ? handleCanvasClick : void 0
-      }) : null;
-      return h("div", { class: "inline-block relative" }, [chart, canvas, tooltip]);
-    };
-  }
-});
-var HeatmapChart_default = HeatmapChart;
-
-export {
-  HeatmapChart,
-  HeatmapChart_default
-};

package/dist/chunk-WM4ESIHG.mjs

@@ -1,83 +0,0 @@
-// src/components/Sidebar.ts
-import { defineComponent, h, computed } from "vue";
-import {
-  classNames,
-  coerceClassValue,
-  layoutSidebarClasses,
-  layoutSidebarCollapsedClasses,
-  getSidebarStyle,
-  mergeStyleValues
-} from "@expcat/tigercat-core";
-var Sidebar = defineComponent({
-  name: "TigerSidebar",
-  inheritAttrs: false,
-  props: {
-    /**
-     * Additional CSS classes
-     */
-    className: {
-      type: String,
-      default: void 0
-    },
-    /**
-     * Sidebar width (CSS value)
-     * @default '256px'
-     */
-    width: {
-      type: String,
-      default: "256px"
-    },
-    /**
-     * Width when collapsed (mini mode).
-     * Set to '0px' to fully hide the sidebar when collapsed.
-     * @default '64px'
-     */
-    collapsedWidth: {
-      type: String,
-      default: "64px"
-    },
-    /**
-     * Whether the sidebar is collapsed
-     * @default false
-     */
-    collapsed: {
-      type: Boolean,
-      default: false
-    },
-    /**
-     * Custom styles
-     */
-    style: {
-      type: Object,
-      default: void 0
-    }
-  },
-  setup(props, { slots, attrs }) {
-    const sidebarClasses = computed(
-      () => classNames(
-        layoutSidebarClasses,
-        props.collapsed && layoutSidebarCollapsedClasses,
-        props.className,
-        coerceClassValue(attrs.class)
-      )
-    );
-    const sidebarStyle = computed(
-      () => getSidebarStyle(props.collapsed, props.width, props.collapsedWidth)
-    );
-    return () => h(
-      "aside",
-      {
-        ...attrs,
-        class: sidebarClasses.value,
-        style: mergeStyleValues(props.style, sidebarStyle.value)
-      },
-      slots.default?.()
-    );
-  }
-});
-var Sidebar_default = Sidebar;
-
-export {
-  Sidebar,
-  Sidebar_default
-};