@expcat/tigercat-react 0.4.3 → 1.0.4

package/dist/chunk-TMQA74FM.js

@@ -0,0 +1,215 @@
+'use strict';
+
+var react = require('react');
+var tigercatCore = require('@expcat/tigercat-core');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/components/Transfer.tsx
+var TRANSFER_KEYS = /* @__PURE__ */ new Set([
+  "value",
+  "dataSource",
+  "size",
+  "disabled",
+  "showSearch",
+  "sourceTitle",
+  "targetTitle",
+  "notFoundText",
+  "filterOption",
+  "onChange"
+]);
+var Transfer = (props) => {
+  const {
+    value = [],
+    dataSource = [],
+    size = "md",
+    disabled = false,
+    showSearch = false,
+    sourceTitle = "Source",
+    targetTitle = "Target",
+    notFoundText = "No data",
+    filterOption,
+    className,
+    onChange,
+    ...rest
+  } = props;
+  const divProps = {};
+  for (const key of Object.keys(rest)) {
+    if (!TRANSFER_KEYS.has(key)) {
+      divProps[key] = rest[key];
+    }
+  }
+  const [sourceSelectedKeys, setSourceSelectedKeys] = react.useState(/* @__PURE__ */ new Set());
+  const [targetSelectedKeys, setTargetSelectedKeys] = react.useState(/* @__PURE__ */ new Set());
+  const [sourceSearch, setSourceSearch] = react.useState("");
+  const [targetSearch, setTargetSearch] = react.useState("");
+  const { sourceItems, targetItems } = react.useMemo(
+    () => tigercatCore.splitTransferData(dataSource, value),
+    [dataSource, value]
+  );
+  const filteredSourceItems = react.useMemo(
+    () => tigercatCore.filterTransferItems(sourceItems, sourceSearch, filterOption),
+    [sourceItems, sourceSearch, filterOption]
+  );
+  const filteredTargetItems = react.useMemo(
+    () => tigercatCore.filterTransferItems(targetItems, targetSearch, filterOption),
+    [targetItems, targetSearch, filterOption]
+  );
+  const canMoveRight = !disabled && [...sourceSelectedKeys].some((key) => {
+    const item = dataSource.find((d) => d.key === key);
+    return item && !item.disabled;
+  });
+  const canMoveLeft = !disabled && [...targetSelectedKeys].some((key) => {
+    const item = dataSource.find((d) => d.key === key);
+    return item && !item.disabled;
+  });
+  function toggleSourceItem(key) {
+    setSourceSelectedKeys((prev) => {
+      const next = new Set(prev);
+      if (next.has(key)) next.delete(key);
+      else next.add(key);
+      return next;
+    });
+  }
+  function toggleTargetItem(key) {
+    setTargetSelectedKeys((prev) => {
+      const next = new Set(prev);
+      if (next.has(key)) next.delete(key);
+      else next.add(key);
+      return next;
+    });
+  }
+  function moveRight() {
+    if (!canMoveRight) return;
+    const keysToMove = [...sourceSelectedKeys].filter((key) => {
+      const item = dataSource.find((d) => d.key === key);
+      return item && !item.disabled;
+    });
+    const newTargetKeys = [...value, ...keysToMove];
+    setSourceSelectedKeys(/* @__PURE__ */ new Set());
+    onChange?.(newTargetKeys, "right", keysToMove);
+  }
+  function moveLeft() {
+    if (!canMoveLeft) return;
+    const keysToRemove = new Set(
+      [...targetSelectedKeys].filter((key) => {
+        const item = dataSource.find((d) => d.key === key);
+        return item && !item.disabled;
+      })
+    );
+    const newTargetKeys = value.filter((k) => !keysToRemove.has(k));
+    setTargetSelectedKeys(/* @__PURE__ */ new Set());
+    onChange?.(newTargetKeys, "left", [...keysToRemove]);
+  }
+  function renderPanel(title, items, selectedKeys, toggleFn, searchValue, onSearch) {
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: tigercatCore.transferPanelClasses, role: "group", "aria-label": title, children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: tigercatCore.transferPanelHeaderClasses, children: /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "font-medium text-[var(--tiger-transfer-title,var(--tiger-text,#111827))]", children: [
+        title,
+        " (",
+        items.length,
+        ")"
+      ] }) }),
+      showSearch && /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          type: "text",
+          className: tigercatCore.transferSearchClasses,
+          placeholder: "Search...",
+          value: searchValue,
+          "aria-label": `Search ${title}`,
+          onChange: (e) => onSearch(e.target.value)
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: tigercatCore.transferPanelBodyClasses, role: "listbox", children: items.length > 0 ? items.map((item) => {
+        const isSelected = selectedKeys.has(item.key);
+        const isDisabled = disabled || !!item.disabled;
+        return /* @__PURE__ */ jsxRuntime.jsxs(
+          "label",
+          {
+            className: tigercatCore.getTransferItemClasses(isSelected, isDisabled, size),
+            role: "option",
+            "aria-selected": isSelected,
+            "aria-disabled": isDisabled,
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx(
+                "input",
+                {
+                  type: "checkbox",
+                  className: tigercatCore.getTransferCheckboxClasses(size),
+                  checked: isSelected,
+                  disabled: isDisabled,
+                  onChange: () => {
+                    if (!isDisabled) toggleFn(item.key);
+                  }
+                }
+              ),
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "flex-1 truncate", children: item.label })
+            ]
+          },
+          String(item.key)
+        );
+      }) : /* @__PURE__ */ jsxRuntime.jsx("div", { className: tigercatCore.transferEmptyClasses, children: notFoundText }) })
+    ] });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: tigercatCore.classNames(tigercatCore.transferBaseClasses, className), ...divProps, children: [
+    renderPanel(
+      sourceTitle,
+      filteredSourceItems,
+      sourceSelectedKeys,
+      toggleSourceItem,
+      sourceSearch,
+      setSourceSearch
+    ),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: tigercatCore.transferOperationClasses, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          className: tigercatCore.getTransferButtonClasses(!canMoveRight),
+          disabled: !canMoveRight,
+          "aria-label": "Move selected to target",
+          onClick: moveRight,
+          children: /* @__PURE__ */ jsxRuntime.jsx(
+            "svg",
+            {
+              className: "w-4 h-4",
+              viewBox: tigercatCore.icon20ViewBox,
+              fill: "currentColor",
+              xmlns: "http://www.w3.org/2000/svg",
+              children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: tigercatCore.chevronRightSolidIcon20PathD, fillRule: "evenodd", clipRule: "evenodd" })
+            }
+          )
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          className: tigercatCore.getTransferButtonClasses(!canMoveLeft),
+          disabled: !canMoveLeft,
+          "aria-label": "Move selected to source",
+          onClick: moveLeft,
+          children: /* @__PURE__ */ jsxRuntime.jsx(
+            "svg",
+            {
+              className: "w-4 h-4",
+              viewBox: tigercatCore.icon20ViewBox,
+              fill: "currentColor",
+              xmlns: "http://www.w3.org/2000/svg",
+              children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: tigercatCore.chevronLeftSolidIcon20PathD, fillRule: "evenodd", clipRule: "evenodd" })
+            }
+          )
+        }
+      )
+    ] }),
+    renderPanel(
+      targetTitle,
+      filteredTargetItems,
+      targetSelectedKeys,
+      toggleTargetItem,
+      targetSearch,
+      setTargetSearch
+    )
+  ] });
+};
+
+exports.Transfer = Transfer;

package/dist/chunk-TQEIMVJD.mjs

@@ -0,0 +1,94 @@
+import { useState, useRef, useMemo, useCallback, useEffect } from 'react';
+import { resolveWatermarkFont, watermarkDefaults, renderWatermarkCanvas, getWatermarkOverlayStyle, classNames, watermarkWrapperClasses } from '@expcat/tigercat-core';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+// src/components/Watermark.tsx
+var Watermark = ({
+  content,
+  image,
+  width = watermarkDefaults.width,
+  height = watermarkDefaults.height,
+  rotate = watermarkDefaults.rotate,
+  zIndex = watermarkDefaults.zIndex,
+  gapX = watermarkDefaults.gapX,
+  gapY = watermarkDefaults.gapY,
+  offsetX = watermarkDefaults.offsetX,
+  offsetY = watermarkDefaults.offsetY,
+  font,
+  className,
+  children,
+  ...props
+}) => {
+  const [base64, setBase64] = useState();
+  const wrapperRef = useRef(null);
+  const resolvedFont = useMemo(() => resolveWatermarkFont(font), [font]);
+  const generate = useCallback(() => {
+    if (image) {
+      const img = new Image();
+      img.crossOrigin = "anonymous";
+      img.onload = () => {
+        const canvas = document.createElement("canvas");
+        const dpr = window.devicePixelRatio || 1;
+        canvas.width = width * dpr;
+        canvas.height = height * dpr;
+        const ctx = canvas.getContext("2d");
+        if (!ctx) return;
+        ctx.scale(dpr, dpr);
+        ctx.translate(width / 2, height / 2);
+        ctx.rotate(rotate * Math.PI / 180);
+        ctx.translate(-width / 2, -height / 2);
+        ctx.drawImage(img, 0, 0, width, height);
+        setBase64(canvas.toDataURL());
+      };
+      img.src = image;
+    } else {
+      setBase64(
+        renderWatermarkCanvas({
+          content,
+          width,
+          height,
+          rotate,
+          font: resolvedFont
+        })
+      );
+    }
+  }, [content, image, width, height, rotate, resolvedFont]);
+  useEffect(() => {
+    generate();
+  }, [generate]);
+  useEffect(() => {
+    if (typeof MutationObserver === "undefined" || !wrapperRef.current) return;
+    const observer = new MutationObserver((mutations) => {
+      for (const m of mutations) {
+        for (const node of Array.from(m.removedNodes)) {
+          if (node.dataset?.watermark === "true") {
+            generate();
+            return;
+          }
+        }
+      }
+    });
+    observer.observe(wrapperRef.current, { childList: true });
+    return () => observer.disconnect();
+  }, [generate]);
+  const overlayStyle = useMemo(
+    () => getWatermarkOverlayStyle({
+      base64Url: base64,
+      width,
+      height,
+      gapX,
+      gapY,
+      offsetX,
+      offsetY,
+      zIndex
+    }),
+    [base64, width, height, gapX, gapY, offsetX, offsetY, zIndex]
+  );
+  const wrapperClasses = useMemo(() => classNames(watermarkWrapperClasses, className), [className]);
+  return /* @__PURE__ */ jsxs("div", { ref: wrapperRef, className: wrapperClasses, ...props, children: [
+    children,
+    /* @__PURE__ */ jsx("div", { "data-watermark": "true", "aria-hidden": "true", style: overlayStyle })
+  ] });
+};
+
+export { Watermark };

package/dist/chunk-TYCRDHE6.mjs

@@ -0,0 +1,143 @@
+import { StatusIcon } from './chunk-FLYJVZED.mjs';
+import { useState, useRef, useCallback, useEffect } from 'react';
+import ReactDOM from 'react-dom';
+import { getTourTargetRect, getTourPopoverPosition, getTourSpotlightStyle, classNames, tourCloseButtonClasses, closeIconPathD, tourTitleClasses, tourDescriptionClasses, tourFooterClasses, tourIndicatorClasses, tourPopoverClasses } from '@expcat/tigercat-core';
+import { jsxs, Fragment, jsx } from 'react/jsx-runtime';
+
+var Tour = ({
+  steps,
+  open = false,
+  current: controlledCurrent,
+  nextText = "Next",
+  prevText = "Previous",
+  finishText = "Finish",
+  closable = true,
+  showIndicators = true,
+  className,
+  onClose,
+  onFinish,
+  onChange
+}) => {
+  const [internalStep, setInternalStep] = useState(0);
+  const currentStep = controlledCurrent ?? internalStep;
+  const step = steps[currentStep];
+  const [targetRect, setTargetRect] = useState();
+  const popoverRef = useRef(null);
+  const updateRect = useCallback(() => {
+    if (step?.target) {
+      setTargetRect(getTourTargetRect(step.target));
+    } else {
+      setTargetRect(void 0);
+    }
+  }, [step]);
+  useEffect(() => {
+    if (open) updateRect();
+  }, [open, currentStep, updateRect]);
+  useEffect(() => {
+    if (!open) return;
+    const handler = () => updateRect();
+    window.addEventListener("resize", handler);
+    window.addEventListener("scroll", handler, true);
+    return () => {
+      window.removeEventListener("resize", handler);
+      window.removeEventListener("scroll", handler, true);
+    };
+  }, [open, updateRect]);
+  const goTo = useCallback(
+    (idx) => {
+      setInternalStep(idx);
+      onChange?.(idx);
+    },
+    [onChange]
+  );
+  const next = useCallback(() => {
+    if (currentStep < steps.length - 1) {
+      goTo(currentStep + 1);
+    } else {
+      onFinish?.();
+      onClose?.();
+    }
+  }, [currentStep, steps.length, goTo, onFinish, onClose]);
+  const prev = useCallback(() => {
+    if (currentStep > 0) goTo(currentStep - 1);
+  }, [currentStep, goTo]);
+  const close = useCallback(() => {
+    onClose?.();
+  }, [onClose]);
+  if (!open || !step) return null;
+  if (typeof document === "undefined") return null;
+  const placement = step.placement ?? "bottom";
+  const showMask = step.mask !== false;
+  const isLast = currentStep === steps.length - 1;
+  const isFirst = currentStep === 0;
+  let popoverStyle;
+  if (targetRect) {
+    const pos = getTourPopoverPosition(targetRect, 320, 160, placement);
+    popoverStyle = { position: "absolute", top: pos.top, left: pos.left };
+  } else {
+    popoverStyle = {
+      position: "fixed",
+      top: "50%",
+      left: "50%",
+      transform: "translate(-50%, -50%)"
+    };
+  }
+  const content = /* @__PURE__ */ jsxs(Fragment, { children: [
+    showMask && targetRect && /* @__PURE__ */ jsx("div", { style: getTourSpotlightStyle(targetRect), "aria-hidden": "true" }),
+    showMask && !targetRect && /* @__PURE__ */ jsx("div", { className: "fixed inset-0 z-[1000] bg-black/45", "aria-hidden": "true", onClick: close }),
+    /* @__PURE__ */ jsxs(
+      "div",
+      {
+        ref: popoverRef,
+        className: classNames(tourPopoverClasses, className),
+        style: popoverStyle,
+        role: "dialog",
+        "aria-modal": "true",
+        children: [
+          closable && /* @__PURE__ */ jsx(
+            "button",
+            {
+              className: tourCloseButtonClasses,
+              type: "button",
+              "aria-label": "Close tour",
+              onClick: close,
+              children: /* @__PURE__ */ jsx(StatusIcon, { path: closeIconPathD, className: "h-4 w-4" })
+            }
+          ),
+          step.title && /* @__PURE__ */ jsx("div", { className: tourTitleClasses, children: step.title }),
+          step.description && /* @__PURE__ */ jsx("div", { className: tourDescriptionClasses, children: step.description }),
+          /* @__PURE__ */ jsxs("div", { className: tourFooterClasses, children: [
+            showIndicators && /* @__PURE__ */ jsxs("span", { className: tourIndicatorClasses, children: [
+              currentStep + 1,
+              " / ",
+              steps.length
+            ] }),
+            /* @__PURE__ */ jsxs("div", { className: "flex items-center", children: [
+              !isFirst && /* @__PURE__ */ jsx(
+                "button",
+                {
+                  type: "button",
+                  className: "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,
+                  children: prevText
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                "button",
+                {
+                  type: "button",
+                  className: "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,
+                  children: isLast ? finishText : nextText
+                }
+              )
+            ] })
+          ] })
+        ]
+      }
+    )
+  ] });
+  return ReactDOM.createPortal(content, document.body);
+};
+
+export { Tour };

package/dist/chunk-TZNTHABR.js

@@ -0,0 +1,58 @@
+'use strict';
+
+var react = require('react');
+var tigercatCore = require('@expcat/tigercat-core');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/components/InfiniteScroll.tsx
+var InfiniteScroll = ({
+  hasMore = true,
+  loading = false,
+  threshold = 100,
+  loadingText = "Loading...",
+  endText = "No more data",
+  direction = "vertical",
+  inverse = false,
+  disabled = false,
+  className,
+  children,
+  loader,
+  end,
+  onLoadMore,
+  ...rest
+}) => {
+  const containerRef = react.useRef(null);
+  const containerClasses = react.useMemo(
+    () => tigercatCore.getInfiniteScrollContainerClasses(direction, className),
+    [direction, className]
+  );
+  const checkScroll = react.useCallback(() => {
+    if (disabled || loading || !hasMore) return;
+    const el = containerRef.current;
+    if (!el) return;
+    if (tigercatCore.shouldLoadMore(el, threshold, direction, inverse)) {
+      onLoadMore?.();
+    }
+  }, [disabled, loading, hasMore, threshold, direction, inverse, onLoadMore]);
+  react.useEffect(() => {
+    const el = containerRef.current;
+    if (!el) return;
+    el.addEventListener("scroll", checkScroll, { passive: true });
+    return () => el.removeEventListener("scroll", checkScroll);
+  }, [checkScroll]);
+  const loaderEl = loading ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: tigercatCore.infiniteScrollLoaderClasses, role: "status", "aria-live": "polite", children: loader ?? loadingText }) : null;
+  const endEl = !hasMore && !loading ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: tigercatCore.infiniteScrollEndClasses, children: end ?? endText }) : null;
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { ref: containerRef, className: tigercatCore.classNames(containerClasses), ...rest, children: inverse ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    loaderEl,
+    children,
+    endEl
+  ] }) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    children,
+    loaderEl,
+    endEl
+  ] }) });
+};
+var InfiniteScroll_default = InfiniteScroll;
+
+exports.InfiniteScroll = InfiniteScroll;
+exports.InfiniteScroll_default = InfiniteScroll_default;

package/dist/chunk-UBKOITHT.mjs

@@ -0,0 +1,142 @@
+import { ChartCanvas } from './chunk-IS467WAO.mjs';
+import React, { useMemo } from 'react';
+import { getChartInnerRect, valueToGaugeAngle, computeGaugeTicks, createGaugeArcPath, createGaugeNeedlePath, classNames, chartAxisTickTextClasses } from '@expcat/tigercat-core';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+var GaugeChart = ({
+  width = 280,
+  height = 200,
+  padding = 24,
+  value,
+  min = 0,
+  max = 100,
+  startAngle = 135,
+  endAngle = 405,
+  arcWidth = 20,
+  showTicks = true,
+  tickCount = 5,
+  valueFormatter,
+  label,
+  segments,
+  trackColor = "var(--tiger-border,#e5e7eb)",
+  color = "var(--tiger-primary,#2563eb)",
+  title: chartTitle,
+  desc,
+  className
+}) => {
+  const innerRect = useMemo(
+    () => getChartInnerRect(width, height, padding),
+    [width, height, padding]
+  );
+  const radius = useMemo(
+    () => Math.min(innerRect.width, innerRect.height) / 2 - 4,
+    [innerRect.width, innerRect.height]
+  );
+  const cx = innerRect.width / 2;
+  const cy = innerRect.height / 2;
+  const needleAngle = useMemo(
+    () => valueToGaugeAngle(value, min, max, startAngle, endAngle),
+    [value, min, max, startAngle, endAngle]
+  );
+  const ticks = useMemo(
+    () => showTicks ? computeGaugeTicks(cx, cy, radius, min, max, startAngle, endAngle, tickCount) : [],
+    [showTicks, cx, cy, radius, min, max, startAngle, endAngle, tickCount]
+  );
+  const trackPath = createGaugeArcPath(cx, cy, radius, startAngle, endAngle, arcWidth);
+  const valuePath = needleAngle > startAngle ? createGaugeArcPath(cx, cy, radius, startAngle, needleAngle, arcWidth) : null;
+  const needlePath = createGaugeNeedlePath(cx, cy, radius - arcWidth - 6, needleAngle);
+  const formattedValue = valueFormatter ? valueFormatter(value) : `${value}`;
+  return /* @__PURE__ */ jsxs(
+    ChartCanvas,
+    {
+      width,
+      height,
+      padding,
+      title: chartTitle,
+      desc,
+      className: classNames(className),
+      children: [
+        /* @__PURE__ */ jsx("path", { d: trackPath, fill: trackColor, strokeWidth: 0 }),
+        segments ? segments.map((seg, i) => {
+          const sStart = valueToGaugeAngle(seg.range[0], min, max, startAngle, endAngle);
+          const sEnd = valueToGaugeAngle(seg.range[1], min, max, startAngle, endAngle);
+          return /* @__PURE__ */ jsx(
+            "path",
+            {
+              d: createGaugeArcPath(cx, cy, radius, sStart, sEnd, arcWidth),
+              fill: seg.color,
+              strokeWidth: 0
+            },
+            `seg-${i}`
+          );
+        }) : valuePath && /* @__PURE__ */ jsx(
+          "path",
+          {
+            d: valuePath,
+            fill: color,
+            strokeWidth: 0,
+            style: { transition: "all 0.3s ease-out" }
+          }
+        ),
+        ticks.map((tick, i) => /* @__PURE__ */ jsxs(React.Fragment, { children: [
+          /* @__PURE__ */ jsx(
+            "line",
+            {
+              x1: tick.x1,
+              y1: tick.y1,
+              x2: tick.x2,
+              y2: tick.y2,
+              stroke: "var(--tiger-text-secondary,#6b7280)",
+              strokeWidth: 1
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            "text",
+            {
+              x: tick.x2 + (tick.x2 - tick.x1) * 1.5,
+              y: tick.y2 + (tick.y2 - tick.y1) * 1.5,
+              className: chartAxisTickTextClasses,
+              textAnchor: "middle",
+              dominantBaseline: "middle",
+              style: { fontSize: "10px" },
+              children: tick.label
+            }
+          )
+        ] }, `tick-${i}`)),
+        /* @__PURE__ */ jsx(
+          "path",
+          {
+            d: needlePath,
+            fill: "var(--tiger-text,#374151)",
+            style: { transition: "all 0.3s ease-out" }
+          }
+        ),
+        /* @__PURE__ */ jsx("circle", { cx, cy, r: 5, fill: "var(--tiger-text,#374151)" }),
+        /* @__PURE__ */ jsx(
+          "text",
+          {
+            x: cx,
+            y: cy + radius * 0.35,
+            className: "fill-[color:var(--tiger-text,#374151)] text-lg font-semibold",
+            textAnchor: "middle",
+            dominantBaseline: "middle",
+            children: formattedValue
+          }
+        ),
+        label && /* @__PURE__ */ jsx(
+          "text",
+          {
+            x: cx,
+            y: cy + radius * 0.35 + 20,
+            className: chartAxisTickTextClasses,
+            textAnchor: "middle",
+            dominantBaseline: "middle",
+            children: label
+          }
+        )
+      ]
+    }
+  );
+};
+
+export { GaugeChart };

package/dist/{chunk-RDIEZKV2.js → chunk-UEJHVPE2.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkSAZ6V6DX_js = require('./chunk-SAZ6V6DX.js');
+var chunkRVCUNEBU_js = require('./chunk-RVCUNEBU.js');
 var react = require('react');
 var tigercatCore = require('@expcat/tigercat-core');
 var jsxRuntime = require('react/jsx-runtime');
@@ -18,7 +18,7 @@ var Radio = ({
   style,
   ...props
 }) => {
-  const groupContext = react.useContext(chunkSAZ6V6DX_js.RadioGroupContext);
+  const groupContext = react.useContext(chunkRVCUNEBU_js.RadioGroupContext);
   const [internalChecked, setInternalChecked] = react.useState(defaultChecked);
   const isCheckedControlled = checked !== void 0;
   const isInGroup = !!groupContext;