@expcat/tigercat-react 0.0.1

package/dist/chunk-HQXZVTP4.mjs

@@ -0,0 +1,199 @@
+import React, { useState, useRef, useEffect, useMemo } from 'react';
+import { classNames, getPopconfirmContainerClasses, getPopconfirmTriggerClasses, getDropdownMenuWrapperClasses, getPopconfirmArrowClasses, getPopconfirmContentClasses, getPopconfirmTitleClasses, getPopconfirmDescriptionClasses, getPopconfirmIconClasses, getPopconfirmButtonsClasses, getPopconfirmCancelButtonClasses, getPopconfirmOkButtonClasses, mergeStyleValues, popconfirmIconStrokeWidth, popconfirmIconViewBox, getPopconfirmIconPath, popconfirmIconPathStrokeLinejoin, popconfirmIconPathStrokeLinecap } from '@expcat/tigercat-core';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+// src/components/Popconfirm.tsx
+var popconfirmIdCounter = 0;
+var createPopconfirmId = () => `tiger-popconfirm-${++popconfirmIdCounter}`;
+var PopconfirmIcon = ({ type }) => /* @__PURE__ */ jsx(
+  "svg",
+  {
+    xmlns: "http://www.w3.org/2000/svg",
+    fill: "none",
+    viewBox: popconfirmIconViewBox,
+    strokeWidth: popconfirmIconStrokeWidth,
+    stroke: "currentColor",
+    children: /* @__PURE__ */ jsx(
+      "path",
+      {
+        strokeLinecap: popconfirmIconPathStrokeLinecap,
+        strokeLinejoin: popconfirmIconPathStrokeLinejoin,
+        d: getPopconfirmIconPath(type)
+      }
+    )
+  }
+);
+var Popconfirm = ({
+  visible,
+  defaultVisible = false,
+  title = "\u786E\u5B9A\u8981\u6267\u884C\u6B64\u64CD\u4F5C\u5417\uFF1F",
+  description,
+  icon = "warning",
+  showIcon = true,
+  okText = "\u786E\u5B9A",
+  cancelText = "\u53D6\u6D88",
+  okType = "primary",
+  placement = "top",
+  disabled = false,
+  className,
+  style,
+  children,
+  titleContent,
+  descriptionContent,
+  onVisibleChange,
+  onConfirm,
+  onCancel,
+  ...divProps
+}) => {
+  const isControlled = visible !== void 0;
+  const [internalVisible, setInternalVisible] = useState(defaultVisible);
+  const currentVisible = isControlled ? visible : internalVisible;
+  const containerRef = useRef(null);
+  const popconfirmIdRef = useRef(null);
+  if (!popconfirmIdRef.current) {
+    popconfirmIdRef.current = createPopconfirmId();
+  }
+  const popconfirmId = popconfirmIdRef.current;
+  const titleId = `${popconfirmId}-title`;
+  const descriptionId = `${popconfirmId}-description`;
+  const describedBy = description || descriptionContent ? descriptionId : void 0;
+  const setVisible = (newVisible) => {
+    if (disabled && newVisible) return;
+    if (!isControlled) {
+      setInternalVisible(newVisible);
+    }
+    onVisibleChange?.(newVisible);
+  };
+  const handleConfirm = () => {
+    onConfirm?.();
+    setVisible(false);
+  };
+  const handleCancel = () => {
+    onCancel?.();
+    setVisible(false);
+  };
+  const handleTriggerClick = () => {
+    if (disabled) return;
+    setVisible(!currentVisible);
+  };
+  useEffect(() => {
+    if (!currentVisible) return;
+    const handleClickOutside = (event) => {
+      const target = event.target;
+      if (!target) return;
+      if (containerRef.current?.contains(target)) return;
+      setVisible(false);
+    };
+    const timeoutId = window.setTimeout(() => {
+      document.addEventListener("click", handleClickOutside);
+    }, 0);
+    return () => {
+      clearTimeout(timeoutId);
+      document.removeEventListener("click", handleClickOutside);
+    };
+  }, [currentVisible]);
+  useEffect(() => {
+    if (!currentVisible) return;
+    const handleKeyDown = (event) => {
+      if (event.key !== "Escape") return;
+      setVisible(false);
+    };
+    document.addEventListener("keydown", handleKeyDown);
+    return () => document.removeEventListener("keydown", handleKeyDown);
+  }, [currentVisible]);
+  const containerClasses = useMemo(
+    () => classNames(getPopconfirmContainerClasses(), className),
+    [className]
+  );
+  const triggerClasses = useMemo(() => getPopconfirmTriggerClasses(disabled), [disabled]);
+  const contentWrapperClasses = useMemo(
+    () => getDropdownMenuWrapperClasses(Boolean(currentVisible), placement),
+    [currentVisible, placement]
+  );
+  const arrowClasses = useMemo(() => getPopconfirmArrowClasses(placement), [placement]);
+  const contentClasses = useMemo(() => getPopconfirmContentClasses(), []);
+  const titleClasses = useMemo(() => getPopconfirmTitleClasses(), []);
+  const descriptionClasses = useMemo(() => getPopconfirmDescriptionClasses(), []);
+  const iconClasses = useMemo(() => getPopconfirmIconClasses(icon), [icon]);
+  const buttonsClasses = useMemo(() => getPopconfirmButtonsClasses(), []);
+  const cancelButtonClasses = useMemo(() => getPopconfirmCancelButtonClasses(), []);
+  const okButtonClasses = useMemo(() => getPopconfirmOkButtonClasses(okType), [okType]);
+  if (!children) {
+    return null;
+  }
+  const mergedStyle = mergeStyleValues(style);
+  const triggerProps = {
+    className: triggerClasses,
+    onClick: (event) => {
+      const target = children;
+      if (React.isValidElement(target)) {
+        const onChildClick = target.props.onClick;
+        if (typeof onChildClick === "function") {
+          onChildClick(event);
+        }
+      }
+      if (event.defaultPrevented) return;
+      handleTriggerClick();
+    },
+    "aria-haspopup": "dialog",
+    "aria-expanded": Boolean(currentVisible),
+    "aria-controls": currentVisible ? popconfirmId : void 0
+  };
+  const triggerNode = (() => {
+    if (React.isValidElement(children)) {
+      return React.cloneElement(children, {
+        ...triggerProps,
+        className: classNames(children.props.className, triggerProps.className)
+      });
+    }
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        ...triggerProps,
+        role: "button",
+        tabIndex: disabled ? -1 : 0,
+        "aria-disabled": disabled,
+        onKeyDown: (event) => {
+          if (disabled) return;
+          if (event.key === "Enter" || event.key === " ") {
+            event.preventDefault();
+            handleTriggerClick();
+          }
+        },
+        children
+      }
+    );
+  })();
+  return /* @__PURE__ */ jsxs("div", { ref: containerRef, className: containerClasses, style: mergedStyle, ...divProps, children: [
+    triggerNode,
+    /* @__PURE__ */ jsx("div", { className: contentWrapperClasses, hidden: !currentVisible, "aria-hidden": !currentVisible, children: /* @__PURE__ */ jsxs("div", { className: "relative", children: [
+      /* @__PURE__ */ jsx("div", { className: arrowClasses, "aria-hidden": "true" }),
+      /* @__PURE__ */ jsxs(
+        "div",
+        {
+          id: popconfirmId,
+          role: "dialog",
+          "aria-modal": "false",
+          "aria-labelledby": titleId,
+          "aria-describedby": describedBy,
+          className: contentClasses,
+          children: [
+            /* @__PURE__ */ jsxs("div", { className: "flex items-start", children: [
+              showIcon && /* @__PURE__ */ jsx("div", { className: iconClasses, "aria-hidden": "true", children: /* @__PURE__ */ jsx(PopconfirmIcon, { type: icon }) }),
+              /* @__PURE__ */ jsxs("div", { className: "flex-1", children: [
+                /* @__PURE__ */ jsx("div", { id: titleId, className: titleClasses, children: titleContent || title }),
+                (description || descriptionContent) && /* @__PURE__ */ jsx("div", { id: descriptionId, className: descriptionClasses, children: descriptionContent || description })
+              ] })
+            ] }),
+            /* @__PURE__ */ jsxs("div", { className: buttonsClasses, children: [
+              /* @__PURE__ */ jsx("button", { type: "button", className: cancelButtonClasses, onClick: handleCancel, children: cancelText }),
+              /* @__PURE__ */ jsx("button", { type: "button", className: okButtonClasses, onClick: handleConfirm, children: okText })
+            ] })
+          ]
+        }
+      )
+    ] }) })
+  ] });
+};
+
+export { Popconfirm };

package/dist/chunk-HUMGEP7S.mjs

@@ -0,0 +1,17 @@
+import { classNames, layoutHeaderClasses } from '@expcat/tigercat-core';
+import { jsx } from 'react/jsx-runtime';
+
+// src/components/Header.tsx
+var Header = ({
+  className,
+  height = "64px",
+  style,
+  children,
+  ...props
+}) => {
+  const headerClasses = classNames(layoutHeaderClasses, className);
+  const headerStyle = { ...style, height };
+  return /* @__PURE__ */ jsx("header", { className: headerClasses, style: headerStyle, ...props, children });
+};
+
+export { Header };

package/dist/chunk-IFY46RWU.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var tigercatCore = require('@expcat/tigercat-core');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/components/Sidebar.tsx
+var Sidebar = ({
+  className,
+  width = "256px",
+  collapsed = false,
+  style,
+  children,
+  ...props
+}) => {
+  const sidebarClasses = tigercatCore.classNames(tigercatCore.layoutSidebarClasses, className);
+  const sidebarStyle = {
+    ...style,
+    width: collapsed ? "0px" : width,
+    minWidth: collapsed ? "0px" : width,
+    overflow: "hidden"
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx("aside", { className: sidebarClasses, style: sidebarStyle, ...props, children: !collapsed && children });
+};
+
+exports.Sidebar = Sidebar;

package/dist/chunk-IQINYCU6.js

@@ -0,0 +1,99 @@
+'use strict';
+
+var tigercatCore = require('@expcat/tigercat-core');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/components/Timeline.tsx
+var Timeline = ({
+  items = [],
+  mode = "left",
+  pending = false,
+  pendingDot,
+  pendingContent,
+  reverse = false,
+  renderItem,
+  renderDot: customRenderDot,
+  className,
+  ...ulProps
+}) => {
+  let processedItems = [...items];
+  if (reverse) processedItems = processedItems.reverse();
+  if (mode === "alternate") {
+    processedItems = processedItems.map((item, index) => ({
+      ...item,
+      position: item.position || (index % 2 === 0 ? "left" : "right")
+    }));
+  }
+  const containerClasses = tigercatCore.classNames(
+    tigercatCore.getTimelineContainerClasses(mode),
+    tigercatCore.timelineListClasses,
+    className
+  );
+  const getItemKey = (item, index) => item.key || index;
+  const wrapCustomDot = (node) => /* @__PURE__ */ jsxRuntime.jsx("div", { className: tigercatCore.getTimelineDotClasses(void 0, true), children: node });
+  const renderDotElement = (item, isPending = false) => {
+    if (customRenderDot) return wrapCustomDot(customRenderDot(item));
+    if (item.dot) return wrapCustomDot(item.dot);
+    if (isPending) {
+      if (pendingDot) {
+        return wrapCustomDot(pendingDot);
+      }
+      return /* @__PURE__ */ jsxRuntime.jsx("div", { className: tigercatCore.getPendingDotClasses() });
+    }
+    const dotClasses = tigercatCore.getTimelineDotClasses(item.color);
+    const dotStyle = item.color ? { backgroundColor: item.color } : {};
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: dotClasses, style: dotStyle });
+  };
+  const renderTimelineItem = (item, index) => {
+    const key = getItemKey(item, index);
+    const isLast = index === processedItems.length - 1 && !pending;
+    const position = item.position;
+    const itemClasses = tigercatCore.getTimelineItemClasses(mode, position, isLast);
+    const tailClasses = tigercatCore.getTimelineTailClasses(mode, position, isLast);
+    const headClasses = tigercatCore.getTimelineHeadClasses(mode, position);
+    const contentClasses = tigercatCore.getTimelineContentClasses(mode, position);
+    if (renderItem) {
+      return /* @__PURE__ */ jsxRuntime.jsxs("li", { className: itemClasses, children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: tailClasses }),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: headClasses, children: renderDotElement(item) }),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: contentClasses, children: renderItem(item, index) })
+      ] }, key);
+    }
+    return /* @__PURE__ */ jsxRuntime.jsxs("li", { className: itemClasses, children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: tailClasses }),
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: headClasses, children: renderDotElement(item) }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: contentClasses, children: [
+        item.label && /* @__PURE__ */ jsxRuntime.jsx("div", { className: tigercatCore.timelineLabelClasses, children: item.label }),
+        item.content && /* @__PURE__ */ jsxRuntime.jsx("div", { className: tigercatCore.timelineDescriptionClasses, children: item.content })
+      ] })
+    ] }, key);
+  };
+  const renderPendingItem = () => {
+    if (!pending) {
+      return null;
+    }
+    const index = processedItems.length;
+    const position = mode === "alternate" ? index % 2 === 0 ? "left" : "right" : void 0;
+    const itemClasses = tigercatCore.getTimelineItemClasses(mode, position, true);
+    const headClasses = tigercatCore.getTimelineHeadClasses(mode, position);
+    const contentClasses = tigercatCore.getTimelineContentClasses(mode, position);
+    return /* @__PURE__ */ jsxRuntime.jsxs("li", { className: itemClasses, children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: headClasses, children: renderDotElement({}, true) }),
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: contentClasses, children: pendingContent || /* @__PURE__ */ jsxRuntime.jsx("div", { className: tigercatCore.timelineDescriptionClasses, children: "Loading..." }) })
+    ] }, "pending");
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "ul",
+    {
+      ...ulProps,
+      className: containerClasses,
+      "aria-busy": ulProps["aria-busy"] ?? (pending ? true : void 0),
+      children: [
+        processedItems.map((item, index) => renderTimelineItem(item, index)),
+        renderPendingItem()
+      ]
+    }
+  );
+};
+
+exports.Timeline = Timeline;

package/dist/chunk-IWENGARY.mjs

@@ -0,0 +1,32 @@
+import { MenuItem } from './chunk-NSGDRTSQ.mjs';
+import React from 'react';
+import { menuItemGroupTitleClasses } from '@expcat/tigercat-core';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+function isComponentNamed(elementType, name) {
+  if (typeof elementType !== "function" && typeof elementType !== "object") return false;
+  const maybeFn = elementType;
+  return maybeFn.displayName === name || maybeFn.name === name;
+}
+var MenuItemGroup = ({
+  title,
+  className,
+  children,
+  level = 0
+}) => {
+  const enhancedChildren = React.Children.map(children, (child) => {
+    if (!React.isValidElement(child)) return child;
+    if (child.type === MenuItem || isComponentNamed(child.type, "SubMenu")) {
+      return React.cloneElement(child, {
+        level
+      });
+    }
+    return child;
+  });
+  return /* @__PURE__ */ jsxs("li", { className: "list-none", children: [
+    title && /* @__PURE__ */ jsx("div", { className: menuItemGroupTitleClasses, children: title }),
+    /* @__PURE__ */ jsx("ul", { role: "group", className, children: enhancedChildren })
+  ] });
+};
+
+export { MenuItemGroup };

package/dist/chunk-IY4LEJYF.js

@@ -0,0 +1,78 @@
+'use strict';
+
+var tigercatCore = require('@expcat/tigercat-core');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/components/Skeleton.tsx
+var Skeleton = (props) => {
+  const {
+    variant = "text",
+    animation = "pulse",
+    width,
+    height,
+    shape = "circle",
+    rows = 1,
+    paragraph = false,
+    className,
+    style,
+    ["aria-label"]: ariaLabelProp,
+    ["aria-labelledby"]: ariaLabelledByProp,
+    ["aria-hidden"]: ariaHiddenProp,
+    ...divProps
+  } = props;
+  const skeletonClasses = tigercatCore.classNames(tigercatCore.getSkeletonClasses(variant, animation, shape), className);
+  const dimensions = tigercatCore.getSkeletonDimensions(variant, width, height);
+  const computedAriaHidden = ariaHiddenProp ?? (ariaLabelProp || ariaLabelledByProp ? void 0 : true);
+  if (variant === "text" && rows > 1) {
+    const rowElements = [];
+    for (let i = 0; i < rows; i++) {
+      const rowStyle = {
+        height: dimensions.height
+      };
+      if (paragraph) {
+        rowStyle.width = tigercatCore.getParagraphRowWidth(i, rows);
+      } else if (dimensions.width) {
+        rowStyle.width = dimensions.width;
+      }
+      rowElements.push(
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            className: tigercatCore.classNames(skeletonClasses, i < rows - 1 && "mb-2"),
+            style: rowStyle,
+            "aria-hidden": computedAriaHidden
+          },
+          i
+        )
+      );
+    }
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        ...divProps,
+        className: tigercatCore.classNames("flex flex-col", className),
+        style,
+        "aria-hidden": computedAriaHidden,
+        children: rowElements
+      }
+    );
+  }
+  const skeletonStyle = {
+    ...style,
+    ...dimensions.width ? { width: dimensions.width } : null,
+    height: dimensions.height
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      ...divProps,
+      className: skeletonClasses,
+      style: skeletonStyle,
+      "aria-label": ariaLabelProp,
+      "aria-labelledby": ariaLabelledByProp,
+      "aria-hidden": computedAriaHidden
+    }
+  );
+};
+
+exports.Skeleton = Skeleton;

package/dist/chunk-JW64IJP2.js

@@ -0,0 +1,210 @@
+'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,
+    children,
+    onSubmit,
+    onValidate,
+    onChange,
+    className,
+    ...props
+  }, ref) => {
+    const [errors, setErrors] = React.useState([]);
+    const [formValues, setFormValues] = React.useState(model);
+    const fieldRulesRef = React__default.default.useRef({});
+    React__default.default.useEffect(() => {
+      setFormValues(model);
+    }, [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 validateField = React.useCallback(
+      async (fieldName, rulesOverride, trigger) => {
+        const fieldRules = rulesOverride ?? fieldRulesRef.current[fieldName] ?? rules?.[fieldName];
+        if (!fieldRules) {
+          return;
+        }
+        const value = tigercatCore.getValueByPath(formValues, fieldName);
+        const error = await tigercatCore.validateField(fieldName, value, fieldRules, formValues, trigger);
+        setErrors((prevErrors) => {
+          const filtered = prevErrors.filter((e) => e.field !== fieldName);
+          if (error) {
+            return [...filtered, { field: fieldName, message: error }];
+          }
+          return filtered;
+        });
+        onValidate?.(fieldName, !error, error);
+      },
+      [rules, formValues, onValidate]
+    );
+    const validate = React.useCallback(async () => {
+      const effectiveRules = getEffectiveRules();
+      if (!effectiveRules) {
+        setErrors([]);
+        return true;
+      }
+      const result = await tigercatCore.validateForm(formValues, effectiveRules);
+      setErrors(result.errors);
+      return result.valid;
+    }, [getEffectiveRules, formValues]);
+    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 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 handleSubmit = React.useCallback(
+      async (event) => {
+        event.preventDefault();
+        const effectiveRules = getEffectiveRules();
+        if (!effectiveRules) {
+          setErrors([]);
+          onSubmit?.({ valid: true, values: formValues, errors: [] });
+          return;
+        }
+        const result = await tigercatCore.validateForm(formValues, effectiveRules);
+        setErrors(result.errors);
+        onSubmit?.({
+          valid: result.valid,
+          values: formValues,
+          errors: result.errors
+        });
+      },
+      [getEffectiveRules, formValues, onSubmit]
+    );
+    React.useImperativeHandle(
+      ref,
+      () => ({
+        validate,
+        validateField,
+        clearValidate,
+        resetFields
+      }),
+      [validate, validateField, clearValidate, resetFields]
+    );
+    const contextValue = React.useMemo(
+      () => ({
+        model: formValues,
+        rules,
+        labelWidth,
+        labelPosition,
+        labelAlign,
+        size,
+        inlineMessage,
+        showRequiredAsterisk,
+        disabled,
+        errors,
+        registerFieldRules,
+        validateField,
+        clearValidate,
+        updateValue
+      }),
+      [
+        formValues,
+        rules,
+        labelWidth,
+        labelPosition,
+        labelAlign,
+        size,
+        inlineMessage,
+        showRequiredAsterisk,
+        disabled,
+        errors,
+        registerFieldRules,
+        validateField,
+        clearValidate,
+        updateValue
+      ]
+    );
+    const formClasses = tigercatCore.classNames(
+      "tiger-form",
+      `tiger-form--label-${labelPosition}`,
+      disabled && "tiger-form--disabled",
+      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;