@expcat/tigercat-react 1.0.7 → 1.2.0

package/dist/chunk-IOHPB4CF.js

@@ -1,148 +0,0 @@
-'use strict';
-
-var chunkDUWAV47E_js = require('./chunk-DUWAV47E.js');
-var React = require('react');
-var tigercatCore = require('@expcat/tigercat-core');
-var jsxRuntime = require('react/jsx-runtime');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var React__default = /*#__PURE__*/_interopDefault(React);
-
-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 = React.useMemo(
-    () => tigercatCore.getChartInnerRect(width, height, padding),
-    [width, height, padding]
-  );
-  const radius = React.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 = React.useMemo(
-    () => tigercatCore.valueToGaugeAngle(value, min, max, startAngle, endAngle),
-    [value, min, max, startAngle, endAngle]
-  );
-  const ticks = React.useMemo(
-    () => showTicks ? tigercatCore.computeGaugeTicks(cx, cy, radius, min, max, startAngle, endAngle, tickCount) : [],
-    [showTicks, cx, cy, radius, min, max, startAngle, endAngle, tickCount]
-  );
-  const trackPath = tigercatCore.createGaugeArcPath(cx, cy, radius, startAngle, endAngle, arcWidth);
-  const valuePath = needleAngle > startAngle ? tigercatCore.createGaugeArcPath(cx, cy, radius, startAngle, needleAngle, arcWidth) : null;
-  const needlePath = tigercatCore.createGaugeNeedlePath(cx, cy, radius - arcWidth - 6, needleAngle);
-  const formattedValue = valueFormatter ? valueFormatter(value) : `${value}`;
-  return /* @__PURE__ */ jsxRuntime.jsxs(
-    chunkDUWAV47E_js.ChartCanvas,
-    {
-      width,
-      height,
-      padding,
-      title: chartTitle,
-      desc,
-      className: tigercatCore.classNames(className),
-      children: [
-        /* @__PURE__ */ jsxRuntime.jsx("path", { d: trackPath, fill: trackColor, strokeWidth: 0 }),
-        segments ? segments.map((seg, i) => {
-          const sStart = tigercatCore.valueToGaugeAngle(seg.range[0], min, max, startAngle, endAngle);
-          const sEnd = tigercatCore.valueToGaugeAngle(seg.range[1], min, max, startAngle, endAngle);
-          return /* @__PURE__ */ jsxRuntime.jsx(
-            "path",
-            {
-              d: tigercatCore.createGaugeArcPath(cx, cy, radius, sStart, sEnd, arcWidth),
-              fill: seg.color,
-              strokeWidth: 0
-            },
-            `seg-${i}`
-          );
-        }) : valuePath && /* @__PURE__ */ jsxRuntime.jsx(
-          "path",
-          {
-            d: valuePath,
-            fill: color,
-            strokeWidth: 0,
-            style: { transition: "all 0.3s ease-out" }
-          }
-        ),
-        ticks.map((tick, i) => /* @__PURE__ */ jsxRuntime.jsxs(React__default.default.Fragment, { children: [
-          /* @__PURE__ */ jsxRuntime.jsx(
-            "line",
-            {
-              x1: tick.x1,
-              y1: tick.y1,
-              x2: tick.x2,
-              y2: tick.y2,
-              stroke: "var(--tiger-text-secondary,#6b7280)",
-              strokeWidth: 1
-            }
-          ),
-          /* @__PURE__ */ jsxRuntime.jsx(
-            "text",
-            {
-              x: tick.x2 + (tick.x2 - tick.x1) * 1.5,
-              y: tick.y2 + (tick.y2 - tick.y1) * 1.5,
-              className: tigercatCore.chartAxisTickTextClasses,
-              textAnchor: "middle",
-              dominantBaseline: "middle",
-              style: { fontSize: "10px" },
-              children: tick.label
-            }
-          )
-        ] }, `tick-${i}`)),
-        /* @__PURE__ */ jsxRuntime.jsx(
-          "path",
-          {
-            d: needlePath,
-            fill: "var(--tiger-text,#374151)",
-            style: { transition: "all 0.3s ease-out" }
-          }
-        ),
-        /* @__PURE__ */ jsxRuntime.jsx("circle", { cx, cy, r: 5, fill: "var(--tiger-text,#374151)" }),
-        /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsx(
-          "text",
-          {
-            x: cx,
-            y: cy + radius * 0.35 + 20,
-            className: tigercatCore.chartAxisTickTextClasses,
-            textAnchor: "middle",
-            dominantBaseline: "middle",
-            children: label
-          }
-        )
-      ]
-    }
-  );
-};
-
-exports.GaugeChart = GaugeChart;

package/dist/chunk-IS467WAO.mjs

@@ -1,39 +0,0 @@
-import { useMemo } from 'react';
-import { getChartInnerRect, classNames, chartCanvasBaseClasses } from '@expcat/tigercat-core';
-import { jsxs, jsx } from 'react/jsx-runtime';
-
-// src/components/ChartCanvas.tsx
-var ChartCanvas = ({
-  width = 320,
-  height = 200,
-  padding = 24,
-  className,
-  title,
-  desc,
-  children,
-  ...props
-}) => {
-  const innerRect = useMemo(
-    () => getChartInnerRect(width, height, padding),
-    [width, height, padding]
-  );
-  const svgClasses = useMemo(() => classNames(chartCanvasBaseClasses, className), [className]);
-  return /* @__PURE__ */ jsxs(
-    "svg",
-    {
-      ...props,
-      width,
-      height,
-      viewBox: `0 0 ${width} ${height}`,
-      className: svgClasses,
-      children: [
-        title ? /* @__PURE__ */ jsx("title", { children: title }) : null,
-        desc ? /* @__PURE__ */ jsx("desc", { children: desc }) : null,
-        /* @__PURE__ */ jsx("g", { transform: `translate(${innerRect.x}, ${innerRect.y})`, children })
-      ]
-    }
-  );
-};
-var ChartCanvas_default = ChartCanvas;
-
-export { ChartCanvas, ChartCanvas_default };

package/dist/chunk-IWP22YTF.js

@@ -1,340 +0,0 @@
-'use strict';
-
-var React = require('react');
-var tigercatCore = require('@expcat/tigercat-core');
-var jsxRuntime = require('react/jsx-runtime');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var React__default = /*#__PURE__*/_interopDefault(React);
-
-// src/components/Form.tsx
-var FormContext = React.createContext(null);
-var useFormContext = () => {
-  const context = React.useContext(FormContext);
-  return context;
-};
-var Form = React.forwardRef(
-  ({
-    model = {},
-    rules,
-    labelWidth,
-    labelPosition = "right",
-    labelAlign = "right",
-    size = "md",
-    inlineMessage = true,
-    showRequiredAsterisk = true,
-    disabled = false,
-    loading = false,
-    children,
-    onSubmit,
-    onValidate,
-    onChange,
-    className,
-    fieldDependencies,
-    undoable = false,
-    maxHistorySize = 50,
-    ...props
-  }, ref) => {
-    const [errors, setErrors] = React.useState([]);
-    const [formValues, setFormValues] = React.useState(model);
-    const fieldRulesRef = React__default.default.useRef({});
-    const formValuesRef = React__default.default.useRef(model);
-    const [historyState, setHistoryState] = React.useState(() => tigercatCore.createFormHistory(model, maxHistorySize));
-    React__default.default.useEffect(() => {
-      setFormValues(model);
-    }, [model]);
-    formValuesRef.current = model;
-    const registerFieldRules = React.useCallback(
-      (fieldName, nextRules) => {
-        if (!fieldName) {
-          return;
-        }
-        if (!nextRules) {
-          delete fieldRulesRef.current[fieldName];
-          return;
-        }
-        fieldRulesRef.current[fieldName] = nextRules;
-      },
-      []
-    );
-    const getEffectiveRules = React.useCallback(() => {
-      const fromForm = rules ?? {};
-      const fromItems = fieldRulesRef.current;
-      const merged = { ...fromForm, ...fromItems };
-      return Object.keys(merged).length > 0 ? merged : void 0;
-    }, [rules]);
-    const resolveFieldRules = React.useCallback(
-      (fieldName, rulesOverride) => {
-        return rulesOverride ?? fieldRulesRef.current[fieldName] ?? rules?.[fieldName];
-      },
-      [rules]
-    );
-    const runFieldValidation = React.useCallback(
-      async (fieldName, rulesOverride, trigger) => {
-        const fieldRules = resolveFieldRules(fieldName, rulesOverride);
-        if (!fieldRules) {
-          return null;
-        }
-        const currentValues = formValuesRef.current;
-        const value = tigercatCore.getValueByPath(currentValues, fieldName);
-        return tigercatCore.validateField(fieldName, value, fieldRules, currentValues, trigger);
-      },
-      [resolveFieldRules]
-    );
-    const validateField = React.useCallback(
-      async (fieldName, rulesOverride, trigger) => {
-        const fieldRules = resolveFieldRules(fieldName, rulesOverride);
-        if (fieldRules) {
-          const error = await runFieldValidation(fieldName, rulesOverride, trigger);
-          setErrors((prevErrors) => {
-            const existing = prevErrors.find((e) => e.field === fieldName);
-            const existingMessage = existing?.message ?? null;
-            if (!error && !existingMessage) return prevErrors;
-            if (error && error === existingMessage) return prevErrors;
-            const filtered = prevErrors.filter((e) => e.field !== fieldName);
-            if (error) {
-              return [...filtered, { field: fieldName, message: error }];
-            }
-            return filtered;
-          });
-          onValidate?.(fieldName, !error, error);
-        }
-        if (fieldDependencies) {
-          const dependents = tigercatCore.getDependentFields(fieldName, fieldDependencies);
-          for (const dep of dependents) {
-            await validateField(dep);
-          }
-        }
-      },
-      [resolveFieldRules, runFieldValidation, onValidate, fieldDependencies]
-    );
-    const runValidation = React.useCallback(async () => {
-      const effectiveRules = getEffectiveRules();
-      if (!effectiveRules) {
-        setErrors([]);
-        return { valid: true, errors: [] };
-      }
-      const result = await tigercatCore.validateForm(formValuesRef.current, effectiveRules);
-      setErrors(result.errors);
-      return result;
-    }, [getEffectiveRules]);
-    const validate = React.useCallback(async () => {
-      const result = await runValidation();
-      return result.valid;
-    }, [runValidation]);
-    const validateFields = React.useCallback(
-      async (fieldNames) => {
-        if (!fieldNames || fieldNames.length === 0) {
-          return true;
-        }
-        const nextErrors = [];
-        const fieldSet = new Set(fieldNames);
-        for (const fieldName of fieldNames) {
-          const fieldRules = resolveFieldRules(fieldName);
-          if (!fieldRules) {
-            onValidate?.(fieldName, true, null);
-            continue;
-          }
-          const error = await runFieldValidation(fieldName);
-          if (error) {
-            nextErrors.push({ field: fieldName, message: error });
-          }
-          onValidate?.(fieldName, !error, error);
-        }
-        setErrors((prevErrors) => {
-          const filtered = prevErrors.filter((entry) => !fieldSet.has(entry.field));
-          return [...filtered, ...nextErrors];
-        });
-        return nextErrors.length === 0;
-      },
-      [resolveFieldRules, runFieldValidation, onValidate]
-    );
-    const clearValidate = React.useCallback((fieldNames) => {
-      if (!fieldNames) {
-        setErrors([]);
-        return;
-      }
-      const fields = Array.isArray(fieldNames) ? fieldNames : [fieldNames];
-      setErrors((prevErrors) => prevErrors.filter((error) => !fields.includes(error.field)));
-    }, []);
-    const resetFields = React.useCallback(() => {
-      clearValidate();
-      setFormValues(model);
-    }, [model, clearValidate]);
-    const addField = React.useCallback(
-      (fieldName, defaultValue) => {
-        if (!fieldName) return;
-        setFormValues((prev) => {
-          const next = { ...prev, [fieldName]: defaultValue ?? null };
-          onChange?.(next);
-          return next;
-        });
-      },
-      [onChange]
-    );
-    const removeField = React.useCallback(
-      (fieldName) => {
-        if (!fieldName) return;
-        setFormValues((prev) => {
-          const { [fieldName]: _, ...next } = prev;
-          onChange?.(next);
-          return next;
-        });
-        clearValidate(fieldName);
-      },
-      [onChange, clearValidate]
-    );
-    const updateValue = React.useCallback(
-      (fieldName, value) => {
-        const setValueByPath = (target, path, nextValue) => {
-          if (!path.includes(".")) {
-            return { ...target, [path]: nextValue };
-          }
-          const segments = path.split(".").filter(Boolean);
-          if (segments.length === 0) {
-            return target;
-          }
-          const clone = { ...target };
-          let cursor = clone;
-          for (let i = 0; i < segments.length; i++) {
-            const key = segments[i];
-            const isLast = i === segments.length - 1;
-            if (isLast) {
-              cursor[key] = nextValue;
-              break;
-            }
-            const existing = cursor[key];
-            const next = existing && typeof existing === "object" && !Array.isArray(existing) ? { ...existing } : {};
-            cursor[key] = next;
-            cursor = next;
-          }
-          return clone;
-        };
-        setFormValues((prevValues) => {
-          const newValues = setValueByPath(prevValues, fieldName, value);
-          onChange?.(newValues);
-          return newValues;
-        });
-      },
-      [onChange]
-    );
-    const snapshotHistory = React.useCallback(() => {
-      if (!undoable) return;
-      setHistoryState((prev) => tigercatCore.pushFormHistory(prev, formValuesRef.current));
-    }, [undoable]);
-    const undo = React.useCallback(() => {
-      if (!undoable) return;
-      setHistoryState((prev) => {
-        const result = tigercatCore.undoFormHistory(prev);
-        if (result) {
-          setFormValues(result.present);
-          formValuesRef.current = result.present;
-          onChange?.(result.present);
-          return result;
-        }
-        return prev;
-      });
-    }, [undoable, onChange]);
-    const redo = React.useCallback(() => {
-      if (!undoable) return;
-      setHistoryState((prev) => {
-        const result = tigercatCore.redoFormHistory(prev);
-        if (result) {
-          setFormValues(result.present);
-          formValuesRef.current = result.present;
-          onChange?.(result.present);
-          return result;
-        }
-        return prev;
-      });
-    }, [undoable, onChange]);
-    const handleSubmit = React.useCallback(
-      async (event) => {
-        event.preventDefault();
-        if (loading) return;
-        const result = await runValidation();
-        onSubmit?.({ ...result, values: formValuesRef.current });
-      },
-      [runValidation, onSubmit, loading]
-    );
-    React.useImperativeHandle(
-      ref,
-      () => ({
-        validate,
-        validateFields,
-        validateField,
-        clearValidate,
-        resetFields,
-        addField,
-        removeField,
-        undo,
-        redo,
-        snapshotHistory,
-        canUndo: tigercatCore.canUndo(historyState),
-        canRedo: tigercatCore.canRedo(historyState)
-      }),
-      [
-        validate,
-        validateFields,
-        validateField,
-        clearValidate,
-        resetFields,
-        addField,
-        removeField,
-        undo,
-        redo,
-        snapshotHistory,
-        historyState
-      ]
-    );
-    const contextValue = React.useMemo(
-      () => ({
-        model: formValues,
-        rules,
-        labelWidth,
-        labelPosition,
-        labelAlign,
-        size,
-        inlineMessage,
-        showRequiredAsterisk,
-        disabled,
-        loading,
-        errors,
-        registerFieldRules,
-        validateField,
-        clearValidate,
-        updateValue
-      }),
-      [
-        formValues,
-        rules,
-        labelWidth,
-        labelPosition,
-        labelAlign,
-        size,
-        inlineMessage,
-        showRequiredAsterisk,
-        disabled,
-        loading,
-        errors,
-        registerFieldRules,
-        validateField,
-        clearValidate,
-        updateValue
-      ]
-    );
-    const formClasses = tigercatCore.classNames(
-      "tiger-form",
-      `tiger-form--label-${labelPosition}`,
-      disabled && "tiger-form--disabled",
-      loading && "tiger-form--loading",
-      className
-    );
-    return /* @__PURE__ */ jsxRuntime.jsx(FormContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsxRuntime.jsx("form", { className: formClasses, onSubmit: handleSubmit, ...props, children }) });
-  }
-);
-Form.displayName = "TigerForm";
-
-exports.Form = Form;
-exports.useFormContext = useFormContext;

package/dist/chunk-JLM4LBUS.js

@@ -1,50 +0,0 @@
-'use strict';
-
-var chunkAJQPGAYL_js = require('./chunk-AJQPGAYL.js');
-var react = require('react');
-var tigercatCore = require('@expcat/tigercat-core');
-var jsxRuntime = require('react/jsx-runtime');
-
-var createTooltipId = tigercatCore.createFloatingIdFactory("tooltip");
-var Tooltip = ({
-  open,
-  defaultOpen = false,
-  content,
-  trigger = "hover",
-  placement = "top",
-  disabled = false,
-  offset = 8,
-  className,
-  style,
-  children,
-  onOpenChange,
-  ...divProps
-}) => {
-  const tooltipIdRef = react.useRef(null);
-  if (!tooltipIdRef.current) tooltipIdRef.current = createTooltipId();
-  const tooltipId = tooltipIdRef.current;
-  const describedBy = content != null ? tooltipId : void 0;
-  const { currentVisible, containerRef, triggerRef, floatingRef, floatingStyles, triggerHandlers } = chunkAJQPGAYL_js.usePopup({ open, defaultOpen, disabled, trigger, placement, offset, onOpenChange });
-  const containerClasses = react.useMemo(
-    () => tigercatCore.classNames(tigercatCore.getTooltipContainerClasses(), className),
-    [className]
-  );
-  const triggerClasses = react.useMemo(() => tigercatCore.getTooltipTriggerClasses(disabled), [disabled]);
-  const contentClasses = react.useMemo(() => tigercatCore.getTooltipContentClasses(), []);
-  if (!children) return null;
-  return /* @__PURE__ */ jsxRuntime.jsxs("div", { ref: containerRef, className: containerClasses, style, ...divProps, children: [
-    /* @__PURE__ */ jsxRuntime.jsx(
-      "div",
-      {
-        ref: triggerRef,
-        className: triggerClasses,
-        "aria-describedby": describedBy,
-        ...triggerHandlers,
-        children
-      }
-    ),
-    currentVisible && /* @__PURE__ */ jsxRuntime.jsx("div", { ref: floatingRef, style: floatingStyles, "aria-hidden": false, children: /* @__PURE__ */ jsxRuntime.jsx("div", { id: tooltipId, role: "tooltip", className: contentClasses, children: content }) })
-  ] });
-};
-
-exports.Tooltip = Tooltip;