@expcat/tigercat-react 0.0.1

package/dist/chunk-QFVE7GKD.js

@@ -0,0 +1,109 @@
+'use strict';
+
+var react = require('react');
+var tigercatCore = require('@expcat/tigercat-core');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/components/Menu.tsx
+var MenuContext = react.createContext(null);
+function useMenuContext() {
+  return react.useContext(MenuContext);
+}
+var Menu = ({
+  mode = "vertical",
+  theme = "light",
+  selectedKeys: controlledSelectedKeys,
+  defaultSelectedKeys = [],
+  openKeys: controlledOpenKeys,
+  defaultOpenKeys = [],
+  collapsed = false,
+  multiple = true,
+  inlineIndent = 24,
+  className,
+  style,
+  onSelect,
+  onOpenChange,
+  children
+}) => {
+  const menuRef = react.useRef(null);
+  const [internalSelectedKeys, setInternalSelectedKeys] = react.useState(defaultSelectedKeys);
+  const [internalOpenKeys, setInternalOpenKeys] = react.useState(defaultOpenKeys);
+  const selectedKeys = controlledSelectedKeys !== void 0 ? controlledSelectedKeys : internalSelectedKeys;
+  const openKeys = controlledOpenKeys !== void 0 ? controlledOpenKeys : internalOpenKeys;
+  const handleSelect = react.useCallback(
+    (key) => {
+      const newSelectedKeys = [key];
+      if (controlledSelectedKeys === void 0) {
+        setInternalSelectedKeys(newSelectedKeys);
+      }
+      onSelect?.(key, { selectedKeys: newSelectedKeys });
+    },
+    [controlledSelectedKeys, onSelect]
+  );
+  const handleOpenChange = react.useCallback(
+    (key) => {
+      const isOpen = openKeys.includes(key);
+      let newOpenKeys;
+      if (isOpen) {
+        newOpenKeys = openKeys.filter((k) => k !== key);
+      } else {
+        if (multiple) {
+          newOpenKeys = [...openKeys, key];
+        } else {
+          newOpenKeys = [key];
+        }
+      }
+      if (controlledOpenKeys === void 0) {
+        setInternalOpenKeys(newOpenKeys);
+      }
+      onOpenChange?.(key, { openKeys: newOpenKeys });
+    },
+    [openKeys, multiple, controlledOpenKeys, onOpenChange]
+  );
+  const menuClasses = react.useMemo(() => {
+    return tigercatCore.classNames(tigercatCore.getMenuClasses(mode, theme, collapsed), className);
+  }, [mode, theme, collapsed, className]);
+  const contextValue = react.useMemo(
+    () => ({
+      mode,
+      theme,
+      collapsed,
+      inlineIndent,
+      selectedKeys,
+      openKeys,
+      handleSelect,
+      handleOpenChange
+    }),
+    [mode, theme, collapsed, inlineIndent, selectedKeys, openKeys, handleSelect, handleOpenChange]
+  );
+  react.useEffect(() => {
+    const root = menuRef.current;
+    if (!root) return;
+    const items = Array.from(
+      root.querySelectorAll('button[data-tiger-menuitem="true"]')
+    ).filter((el) => !el.disabled && !el.closest('[data-tiger-menu-hidden="true"]'));
+    if (items.length === 0) return;
+    const hasActive = items.some((el) => el.tabIndex === 0);
+    if (hasActive) return;
+    const selected = items.find((el) => el.dataset.tigerSelected === "true");
+    const active = selected ?? items[0];
+    items.forEach((el) => {
+      el.tabIndex = el === active ? 0 : -1;
+    });
+  }, [mode, collapsed, selectedKeys, openKeys]);
+  return /* @__PURE__ */ jsxRuntime.jsx(MenuContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsxRuntime.jsx(
+    "ul",
+    {
+      ref: menuRef,
+      className: menuClasses,
+      style,
+      role: "menu",
+      "data-tiger-menu-root": "true",
+      "data-tiger-menu-mode": mode,
+      children
+    }
+  ) });
+};
+
+exports.Menu = Menu;
+exports.useMenuContext = useMenuContext;

package/dist/chunk-QL6OBKEN.js

@@ -0,0 +1,84 @@
+'use strict';
+
+var react = require('react');
+var tigercatCore = require('@expcat/tigercat-core');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/components/Input.tsx
+var Input = ({
+  size = "md",
+  type = "text",
+  value,
+  defaultValue,
+  placeholder = "",
+  disabled = false,
+  readonly = false,
+  required = false,
+  maxLength,
+  minLength,
+  name,
+  id,
+  autoComplete,
+  autoFocus = false,
+  onInput,
+  onChange,
+  onFocus,
+  onBlur,
+  className,
+  ...props
+}) => {
+  const inputRef = react.useRef(null);
+  const [internalValue, setInternalValue] = react.useState(defaultValue ?? "");
+  const isControlled = value !== void 0;
+  const inputValue = isControlled ? value : internalValue;
+  react.useEffect(() => {
+    if (autoFocus && inputRef.current) {
+      inputRef.current.focus();
+    }
+  }, [autoFocus]);
+  const getNextValue = (target) => {
+    if (type === "number") {
+      return Number.isNaN(target.valueAsNumber) ? target.value : target.valueAsNumber;
+    }
+    return target.value;
+  };
+  const handleInput = (event) => {
+    if (!isControlled) {
+      setInternalValue(getNextValue(event.currentTarget));
+    }
+    onInput?.(event);
+  };
+  const handleChange = (event) => {
+    if (!isControlled) {
+      setInternalValue(getNextValue(event.currentTarget));
+    }
+    onChange?.(event);
+  };
+  const inputClasses = tigercatCore.classNames(tigercatCore.getInputClasses(size), className);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "input",
+    {
+      ...props,
+      ref: inputRef,
+      className: inputClasses,
+      type,
+      value: inputValue,
+      placeholder,
+      disabled,
+      readOnly: readonly,
+      required,
+      maxLength,
+      minLength,
+      name,
+      id,
+      autoComplete,
+      autoFocus,
+      onInput: handleInput,
+      onChange: handleChange,
+      onFocus,
+      onBlur
+    }
+  );
+};
+
+exports.Input = Input;

package/dist/chunk-QL6UEG3U.js

@@ -0,0 +1,27 @@
+'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/ConfigProvider.tsx
+var TigerConfigContext = React__default.default.createContext({});
+var ConfigProvider = ({ locale, children }) => {
+  const parent = React.useContext(TigerConfigContext);
+  const value = React.useMemo(() => {
+    return {
+      locale: tigercatCore.mergeTigerLocale(parent.locale, locale)
+    };
+  }, [parent.locale, locale]);
+  return /* @__PURE__ */ jsxRuntime.jsx(TigerConfigContext.Provider, { value, children });
+};
+function useTigerConfig() {
+  return React.useContext(TigerConfigContext);
+}
+
+exports.ConfigProvider = ConfigProvider;
+exports.useTigerConfig = useTigerConfig;

package/dist/chunk-QN7NIX7D.mjs

@@ -0,0 +1,82 @@
+import { useRef, useState, useEffect } from 'react';
+import { classNames, getInputClasses } from '@expcat/tigercat-core';
+import { jsx } from 'react/jsx-runtime';
+
+// src/components/Input.tsx
+var Input = ({
+  size = "md",
+  type = "text",
+  value,
+  defaultValue,
+  placeholder = "",
+  disabled = false,
+  readonly = false,
+  required = false,
+  maxLength,
+  minLength,
+  name,
+  id,
+  autoComplete,
+  autoFocus = false,
+  onInput,
+  onChange,
+  onFocus,
+  onBlur,
+  className,
+  ...props
+}) => {
+  const inputRef = useRef(null);
+  const [internalValue, setInternalValue] = useState(defaultValue ?? "");
+  const isControlled = value !== void 0;
+  const inputValue = isControlled ? value : internalValue;
+  useEffect(() => {
+    if (autoFocus && inputRef.current) {
+      inputRef.current.focus();
+    }
+  }, [autoFocus]);
+  const getNextValue = (target) => {
+    if (type === "number") {
+      return Number.isNaN(target.valueAsNumber) ? target.value : target.valueAsNumber;
+    }
+    return target.value;
+  };
+  const handleInput = (event) => {
+    if (!isControlled) {
+      setInternalValue(getNextValue(event.currentTarget));
+    }
+    onInput?.(event);
+  };
+  const handleChange = (event) => {
+    if (!isControlled) {
+      setInternalValue(getNextValue(event.currentTarget));
+    }
+    onChange?.(event);
+  };
+  const inputClasses = classNames(getInputClasses(size), className);
+  return /* @__PURE__ */ jsx(
+    "input",
+    {
+      ...props,
+      ref: inputRef,
+      className: inputClasses,
+      type,
+      value: inputValue,
+      placeholder,
+      disabled,
+      readOnly: readonly,
+      required,
+      maxLength,
+      minLength,
+      name,
+      id,
+      autoComplete,
+      autoFocus,
+      onInput: handleInput,
+      onChange: handleChange,
+      onFocus,
+      onBlur
+    }
+  );
+};
+
+export { Input };

package/dist/chunk-QORSSZX4.js

@@ -0,0 +1,144 @@
+'use strict';
+
+var react = require('react');
+var tigercatCore = require('@expcat/tigercat-core');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/components/Popover.tsx
+var popoverIdCounter = 0;
+var createPopoverId = () => `tiger-popover-${++popoverIdCounter}`;
+var Popover = ({
+  visible,
+  defaultVisible = false,
+  title,
+  content,
+  trigger = "click",
+  placement = "top",
+  disabled = false,
+  width,
+  className,
+  style,
+  children,
+  titleContent,
+  contentContent,
+  onVisibleChange,
+  ...divProps
+}) => {
+  const isControlled = visible !== void 0;
+  const [internalVisible, setInternalVisible] = react.useState(defaultVisible);
+  const currentVisible = isControlled ? visible : internalVisible;
+  const containerRef = react.useRef(null);
+  const popoverIdRef = react.useRef(null);
+  if (!popoverIdRef.current) {
+    popoverIdRef.current = createPopoverId();
+  }
+  const popoverId = popoverIdRef.current;
+  const titleId = `${popoverId}-title`;
+  const contentId = `${popoverId}-content`;
+  const setVisible = react.useCallback(
+    (nextVisible) => {
+      if (disabled && nextVisible) return;
+      if (!isControlled) {
+        setInternalVisible(nextVisible);
+      }
+      onVisibleChange?.(nextVisible);
+    },
+    [disabled, isControlled, onVisibleChange]
+  );
+  const handleTriggerClick = () => {
+    if (disabled || trigger !== "click") return;
+    setVisible(!currentVisible);
+  };
+  const handleTriggerMouseEnter = () => {
+    if (disabled || trigger !== "hover") return;
+    setVisible(true);
+  };
+  const handleTriggerMouseLeave = () => {
+    if (disabled || trigger !== "hover") return;
+    setVisible(false);
+  };
+  const handleTriggerFocus = () => {
+    if (disabled || trigger !== "focus") return;
+    setVisible(true);
+  };
+  const handleTriggerBlur = () => {
+    if (disabled || trigger !== "focus") return;
+    setVisible(false);
+  };
+  react.useEffect(() => {
+    if (!currentVisible || trigger !== "click") return;
+    const handleClickOutside = (event) => {
+      const target = event.target;
+      if (!target) return;
+      if (containerRef.current?.contains(target)) return;
+      setVisible(false);
+    };
+    const timeoutId = setTimeout(() => {
+      document.addEventListener("click", handleClickOutside);
+    }, 0);
+    return () => {
+      clearTimeout(timeoutId);
+      document.removeEventListener("click", handleClickOutside);
+    };
+  }, [currentVisible, trigger, setVisible]);
+  react.useEffect(() => {
+    if (!currentVisible || trigger === "manual") return;
+    const handleKeyDown = (event) => {
+      if (event.key !== "Escape") return;
+      setVisible(false);
+    };
+    document.addEventListener("keydown", handleKeyDown);
+    return () => document.removeEventListener("keydown", handleKeyDown);
+  }, [currentVisible, trigger, setVisible]);
+  const containerClasses = tigercatCore.classNames(tigercatCore.getPopoverContainerClasses(), className);
+  const triggerClasses = tigercatCore.getPopoverTriggerClasses(disabled);
+  const contentWrapperClasses = tigercatCore.getDropdownMenuWrapperClasses(currentVisible, placement);
+  const contentClasses = tigercatCore.getPopoverContentClasses(width);
+  const titleClasses = tigercatCore.getPopoverTitleClasses();
+  const contentTextClasses = tigercatCore.getPopoverContentTextClasses();
+  const triggerHandlers = {};
+  if (trigger === "click") {
+    triggerHandlers.onClick = handleTriggerClick;
+  } else if (trigger === "hover") {
+    triggerHandlers.onMouseEnter = handleTriggerMouseEnter;
+    triggerHandlers.onMouseLeave = handleTriggerMouseLeave;
+  } else if (trigger === "focus") {
+    triggerHandlers.onFocus = handleTriggerFocus;
+    triggerHandlers.onBlur = handleTriggerBlur;
+  }
+  if (!children) {
+    return null;
+  }
+  const hasTitle = Boolean(title || titleContent);
+  const hasContent = Boolean(content || contentContent);
+  const describedBy = hasContent ? contentId : void 0;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { ref: containerRef, className: containerClasses, style, ...divProps, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        className: triggerClasses,
+        "aria-haspopup": "dialog",
+        "aria-disabled": disabled ? "true" : void 0,
+        ...triggerHandlers,
+        children
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: contentWrapperClasses, hidden: !currentVisible, "aria-hidden": !currentVisible, children: /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        id: popoverId,
+        role: "dialog",
+        "aria-modal": "false",
+        "aria-labelledby": hasTitle ? titleId : void 0,
+        "aria-describedby": describedBy,
+        className: contentClasses,
+        children: [
+          hasTitle && /* @__PURE__ */ jsxRuntime.jsx("div", { id: titleId, className: titleClasses, children: titleContent || title }),
+          hasContent && /* @__PURE__ */ jsxRuntime.jsx("div", { id: contentId, className: contentTextClasses, children: contentContent || content })
+        ]
+      }
+    ) })
+  ] });
+};
+
+exports.Popover = Popover;

package/dist/chunk-R4JSBXGG.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var tigercatCore = require('@expcat/tigercat-core');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/components/Layout.tsx
+var Layout = ({ className, children, ...props }) => {
+  const layoutClasses = tigercatCore.classNames(tigercatCore.layoutRootClasses, className);
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: layoutClasses, ...props, children });
+};
+
+exports.Layout = Layout;