@expcat/tigercat-react 2.1.2 → 2.1.3

package/dist/chunk-OQLP452R.mjs

@@ -1,468 +0,0 @@
-import {
-  useTigerConfig
-} from "./chunk-YSIXURBW.mjs";
-
-// src/components/Form.tsx
-import React, {
-  createContext,
-  useContext,
-  useState,
-  useCallback,
-  useMemo,
-  useImperativeHandle,
-  forwardRef
-} from "react";
-import {
-  classNames,
-  validateForm,
-  validateField as validateFieldUtil,
-  getValueByPath,
-  createFormErrorMap,
-  getDependentFields,
-  createFormConditionDependencies,
-  resolveConditionalFormRules,
-  resolveFormFieldConditionState,
-  createFormValidationDebouncer,
-  createFormHistory,
-  pushFormHistory,
-  undoFormHistory,
-  redoFormHistory,
-  canUndo,
-  canRedo,
-  mergeTigerLocale,
-  getFormValidationLabels
-} from "@expcat/tigercat-core";
-import { jsx } from "react/jsx-runtime";
-var FormContext = createContext(null);
-var useFormContext = () => {
-  const context = useContext(FormContext);
-  return context;
-};
-var Form = forwardRef(
-  ({
-    model = {},
-    rules,
-    labelWidth,
-    labelPosition = "right",
-    labelAlign,
-    size = "md",
-    inlineMessage = true,
-    showRequiredAsterisk = true,
-    disabled = false,
-    loading = false,
-    children,
-    onSubmit,
-    onValidate,
-    onChange,
-    className,
-    fieldDependencies,
-    conditions,
-    validateDebounce = 0,
-    undoable = false,
-    maxHistorySize = 50,
-    locale,
-    ...props
-  }, ref) => {
-    const resolvedLabelAlign = labelAlign ?? (labelPosition === "top" ? "left" : "right");
-    const config = useTigerConfig();
-    const validationMessages = useMemo(
-      () => getFormValidationLabels(mergeTigerLocale(config.locale, locale)),
-      [config.locale, locale]
-    );
-    const [errors, setErrors] = useState([]);
-    const fieldRulesRef = React.useRef({});
-    const fieldConditionsRef = React.useRef({});
-    const formValuesRef = React.useRef(model);
-    const initialValuesRef = React.useRef({ ...model });
-    const validationDebouncerRef = React.useRef(
-      createFormValidationDebouncer({ delay: validateDebounce })
-    );
-    const errorsByField = useMemo(() => createFormErrorMap(errors), [errors]);
-    const [historyState, setHistoryState] = useState(() => createFormHistory(model, maxHistorySize));
-    React.useEffect(() => {
-      validationDebouncerRef.current.cancel();
-      validationDebouncerRef.current = createFormValidationDebouncer({ delay: validateDebounce });
-      return () => validationDebouncerRef.current.cancel();
-    }, [validateDebounce]);
-    formValuesRef.current = model;
-    const registerFieldRules = useCallback(
-      (fieldName, nextRules) => {
-        if (!fieldName) {
-          return;
-        }
-        if (!nextRules) {
-          delete fieldRulesRef.current[fieldName];
-          return;
-        }
-        fieldRulesRef.current[fieldName] = nextRules;
-      },
-      []
-    );
-    const registerFieldCondition = useCallback(
-      (fieldName, condition) => {
-        if (!fieldName) {
-          return;
-        }
-        if (!condition) {
-          delete fieldConditionsRef.current[fieldName];
-          return;
-        }
-        fieldConditionsRef.current[fieldName] = condition;
-      },
-      []
-    );
-    const getEffectiveConditions = useCallback(() => {
-      const merged = { ...conditions ?? {}, ...fieldConditionsRef.current };
-      return Object.keys(merged).length > 0 ? merged : void 0;
-    }, [conditions]);
-    const getMergedFieldCondition = useCallback(
-      (fieldName, conditionOverride) => {
-        const base = getEffectiveConditions()?.[fieldName];
-        return base || conditionOverride ? { ...base ?? {}, ...conditionOverride ?? {} } : void 0;
-      },
-      [getEffectiveConditions]
-    );
-    const getFieldConditionState = useCallback(
-      (fieldName, conditionOverride) => {
-        return resolveFormFieldConditionState(
-          formValuesRef.current,
-          getMergedFieldCondition(fieldName, conditionOverride)
-        );
-      },
-      [getMergedFieldCondition]
-    );
-    const getEffectiveRules = useCallback(() => {
-      const fromForm = rules ?? {};
-      const fromItems = fieldRulesRef.current;
-      const merged = { ...fromForm, ...fromItems };
-      const nextRules = Object.keys(merged).length > 0 ? merged : void 0;
-      return resolveConditionalFormRules(formValuesRef.current, nextRules, getEffectiveConditions());
-    }, [rules, getEffectiveConditions]);
-    const resolveFieldRules = useCallback(
-      (fieldName, rulesOverride) => {
-        const fieldRules = rulesOverride ?? fieldRulesRef.current[fieldName] ?? rules?.[fieldName];
-        const resolved = resolveConditionalFormRules(
-          formValuesRef.current,
-          fieldRules ? { [fieldName]: fieldRules } : void 0,
-          getEffectiveConditions()
-        );
-        return resolved?.[fieldName];
-      },
-      [rules, getEffectiveConditions]
-    );
-    const getDependencyMap = useCallback(() => {
-      const conditionDependencies = createFormConditionDependencies(getEffectiveConditions());
-      if (!fieldDependencies && conditionDependencies.size === 0) {
-        return void 0;
-      }
-      const merged = new Map(fieldDependencies ?? []);
-      for (const [fieldName, dependencies] of conditionDependencies.entries()) {
-        const current = merged.get(fieldName) ?? [];
-        merged.set(fieldName, Array.from(/* @__PURE__ */ new Set([...current, ...dependencies])));
-      }
-      return merged;
-    }, [fieldDependencies, getEffectiveConditions]);
-    const runFieldValidation = useCallback(
-      async (fieldName, rulesOverride, trigger) => {
-        const fieldRules = resolveFieldRules(fieldName, rulesOverride);
-        if (!fieldRules) {
-          return null;
-        }
-        const currentValues = formValuesRef.current;
-        const value = getValueByPath(currentValues, fieldName);
-        return validateFieldUtil(
-          fieldName,
-          value,
-          fieldRules,
-          currentValues,
-          trigger,
-          validationMessages
-        );
-      },
-      [resolveFieldRules, validationMessages]
-    );
-    const validateFieldNow = useCallback(
-      async (fieldName, rulesOverride, trigger) => {
-        const conditionState = getFieldConditionState(fieldName);
-        if (!conditionState.shown || conditionState.disabled) {
-          setErrors((prevErrors) => prevErrors.filter((error) => error.field !== fieldName));
-          onValidate?.(fieldName, true, null);
-          return;
-        }
-        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);
-        }
-        const dependencyMap = getDependencyMap();
-        if (dependencyMap) {
-          const dependents = getDependentFields(fieldName, dependencyMap);
-          for (const dep of dependents) {
-            await validateFieldNow(dep);
-          }
-        }
-      },
-      [resolveFieldRules, runFieldValidation, onValidate, getFieldConditionState, getDependencyMap]
-    );
-    const validateField = useCallback(
-      async (fieldName, rulesOverride, trigger) => {
-        if (trigger === "change" && validateDebounce > 0) {
-          return validationDebouncerRef.current.schedule(
-            fieldName,
-            () => validateFieldNow(fieldName, rulesOverride, trigger)
-          );
-        }
-        validationDebouncerRef.current.cancel(fieldName);
-        return validateFieldNow(fieldName, rulesOverride, trigger);
-      },
-      [validateDebounce, validateFieldNow]
-    );
-    const runValidation = useCallback(async () => {
-      validationDebouncerRef.current.cancel();
-      const effectiveRules = getEffectiveRules();
-      if (!effectiveRules) {
-        setErrors([]);
-        return { valid: true, errors: [] };
-      }
-      const result = await validateForm(formValuesRef.current, effectiveRules, validationMessages);
-      setErrors(result.errors);
-      return result;
-    }, [getEffectiveRules, validationMessages]);
-    const validate = useCallback(async () => {
-      const result = await runValidation();
-      return result.valid;
-    }, [runValidation]);
-    const validateFields = useCallback(
-      async (fieldNames) => {
-        if (!fieldNames || fieldNames.length === 0) {
-          return true;
-        }
-        fieldNames.forEach((fieldName) => validationDebouncerRef.current.cancel(fieldName));
-        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 = useCallback((fieldNames) => {
-      if (!fieldNames) {
-        validationDebouncerRef.current.cancel();
-        setErrors([]);
-        return;
-      }
-      const fields = Array.isArray(fieldNames) ? fieldNames : [fieldNames];
-      fields.forEach((fieldName) => validationDebouncerRef.current.cancel(fieldName));
-      setErrors((prevErrors) => prevErrors.filter((error) => !fields.includes(error.field)));
-    }, []);
-    const resetFields = useCallback(() => {
-      clearValidate();
-      const next = { ...initialValuesRef.current };
-      formValuesRef.current = next;
-      onChange?.(next);
-      if (undoable) {
-        setHistoryState(createFormHistory(next, maxHistorySize));
-      }
-    }, [clearValidate, onChange, undoable, maxHistorySize]);
-    const addField = useCallback(
-      (fieldName, defaultValue) => {
-        if (!fieldName) return;
-        const next = { ...formValuesRef.current, [fieldName]: defaultValue ?? null };
-        formValuesRef.current = next;
-        onChange?.(next);
-      },
-      [onChange]
-    );
-    const removeField = useCallback(
-      (fieldName) => {
-        if (!fieldName) return;
-        const { [fieldName]: _, ...next } = formValuesRef.current;
-        formValuesRef.current = next;
-        onChange?.(next);
-        clearValidate(fieldName);
-      },
-      [onChange, clearValidate]
-    );
-    const updateValue = 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;
-        };
-        const newValues = setValueByPath(formValuesRef.current, fieldName, value);
-        formValuesRef.current = newValues;
-        onChange?.(newValues);
-      },
-      [onChange]
-    );
-    const snapshotHistory = useCallback(() => {
-      if (!undoable) return;
-      setHistoryState((prev) => pushFormHistory(prev, formValuesRef.current));
-    }, [undoable]);
-    const undo = useCallback(() => {
-      if (!undoable) return;
-      setHistoryState((prev) => {
-        const result = undoFormHistory(prev);
-        if (result) {
-          formValuesRef.current = result.present;
-          onChange?.(result.present);
-          return result;
-        }
-        return prev;
-      });
-    }, [undoable, onChange]);
-    const redo = useCallback(() => {
-      if (!undoable) return;
-      setHistoryState((prev) => {
-        const result = redoFormHistory(prev);
-        if (result) {
-          formValuesRef.current = result.present;
-          onChange?.(result.present);
-          return result;
-        }
-        return prev;
-      });
-    }, [undoable, onChange]);
-    const handleSubmit = useCallback(
-      async (event) => {
-        event.preventDefault();
-        if (loading) return;
-        const result = await runValidation();
-        onSubmit?.({ ...result, values: formValuesRef.current });
-      },
-      [runValidation, onSubmit, loading]
-    );
-    useImperativeHandle(
-      ref,
-      () => ({
-        validate,
-        validateFields,
-        validateField,
-        clearValidate,
-        resetFields,
-        addField,
-        removeField,
-        undo,
-        redo,
-        snapshotHistory,
-        canUndo: canUndo(historyState),
-        canRedo: canRedo(historyState)
-      }),
-      [
-        validate,
-        validateFields,
-        validateField,
-        clearValidate,
-        resetFields,
-        addField,
-        removeField,
-        undo,
-        redo,
-        snapshotHistory,
-        historyState
-      ]
-    );
-    const contextValue = useMemo(
-      () => ({
-        model,
-        rules,
-        labelWidth,
-        labelPosition,
-        labelAlign: resolvedLabelAlign,
-        size,
-        inlineMessage,
-        showRequiredAsterisk,
-        disabled,
-        loading,
-        errors,
-        errorsByField,
-        registerFieldRules,
-        registerFieldCondition,
-        getFieldConditionState,
-        validateField,
-        clearValidate,
-        updateValue
-      }),
-      [
-        model,
-        rules,
-        labelWidth,
-        labelPosition,
-        resolvedLabelAlign,
-        size,
-        inlineMessage,
-        showRequiredAsterisk,
-        disabled,
-        loading,
-        errors,
-        errorsByField,
-        registerFieldRules,
-        registerFieldCondition,
-        getFieldConditionState,
-        validateField,
-        clearValidate,
-        updateValue
-      ]
-    );
-    const formClasses = classNames(
-      "tiger-form",
-      `tiger-form--label-${labelPosition}`,
-      disabled && "tiger-form--disabled",
-      loading && "tiger-form--loading",
-      className
-    );
-    return /* @__PURE__ */ jsx(FormContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsx("form", { className: formClasses, onSubmit: handleSubmit, ...props, children }) });
-  }
-);
-Form.displayName = "TigerForm";
-
-export {
-  useFormContext,
-  Form
-};

package/dist/chunk-OXGAZPPS.mjs

@@ -1,147 +0,0 @@
-import {
-  StatusIcon
-} from "./chunk-FLYJVZED.mjs";
-
-// src/components/Alert.tsx
-import { useState, useMemo, useCallback, useEffect } from "react";
-import {
-  classNames,
-  getAlertTypeClasses,
-  defaultAlertThemeColors,
-  alertBaseClasses,
-  alertSizeClasses,
-  alertIconSizeClasses,
-  alertTitleSizeClasses,
-  alertDescriptionSizeClasses,
-  alertCloseButtonBaseClasses,
-  alertIconContainerClasses,
-  alertContentClasses,
-  getAlertIconPath,
-  alertCloseIconPath,
-  alertBannerClasses,
-  alertCountdownContainerClasses,
-  alertCountdownBarClasses,
-  alertCountdownColorClasses
-} from "@expcat/tigercat-core";
-import { jsx, jsxs } from "react/jsx-runtime";
-var Alert = ({
-  type = "info",
-  size = "md",
-  title,
-  description,
-  showIcon = true,
-  closable = false,
-  closeAriaLabel = "Close alert",
-  duration,
-  banner = false,
-  showCountdown = false,
-  className,
-  children,
-  titleSlot,
-  descriptionSlot,
-  onClose,
-  ...props
-}) => {
-  const [visible, setVisible] = useState(true);
-  const [countdownProgress, setCountdownProgress] = useState(100);
-  const colorScheme = useMemo(() => getAlertTypeClasses(type, defaultAlertThemeColors), [type]);
-  const alertClasses = useMemo(
-    () => classNames(
-      alertBaseClasses,
-      alertSizeClasses[size],
-      colorScheme.bg,
-      colorScheme.border,
-      banner && alertBannerClasses,
-      className
-    ),
-    [size, colorScheme, banner, className]
-  );
-  const iconClasses = useMemo(
-    () => classNames(alertIconSizeClasses[size], colorScheme.icon),
-    [size, colorScheme]
-  );
-  const titleClasses = useMemo(
-    () => classNames(alertTitleSizeClasses[size], colorScheme.title),
-    [size, colorScheme]
-  );
-  const descriptionClasses = useMemo(
-    () => classNames(alertDescriptionSizeClasses[size], colorScheme.description),
-    [size, colorScheme]
-  );
-  const closeButtonClasses = useMemo(
-    () => classNames(
-      alertCloseButtonBaseClasses,
-      colorScheme.closeButton,
-      colorScheme.closeButtonHover,
-      colorScheme.focus
-    ),
-    [colorScheme]
-  );
-  const handleClose = useCallback(
-    (event) => {
-      onClose?.(event);
-      if (!event.defaultPrevented) {
-        setVisible(false);
-      }
-    },
-    [onClose]
-  );
-  useEffect(() => {
-    if (duration && duration > 0 && closable) {
-      setCountdownProgress(100);
-      const timer = setTimeout(() => {
-        setVisible(false);
-        onClose?.();
-      }, duration);
-      let countdownTimer;
-      if (showCountdown) {
-        const startTime = Date.now();
-        countdownTimer = setInterval(() => {
-          const elapsed = Date.now() - startTime;
-          setCountdownProgress(Math.max(0, 100 - elapsed / duration * 100));
-        }, 50);
-      }
-      return () => {
-        clearTimeout(timer);
-        if (countdownTimer) clearInterval(countdownTimer);
-      };
-    }
-  }, [duration, closable, showCountdown, onClose]);
-  if (!visible) {
-    return null;
-  }
-  const iconPath = getAlertIconPath(type);
-  const hasTitle = !!(title || titleSlot);
-  const hasDescription = !!(description || descriptionSlot);
-  const hasDefaultContent = !hasTitle && !hasDescription && !!children;
-  const hasContent = hasTitle || hasDescription || hasDefaultContent;
-  return /* @__PURE__ */ jsxs("div", { ...props, className: alertClasses, role: "alert", children: [
-    showIcon && /* @__PURE__ */ jsx("div", { className: alertIconContainerClasses, children: /* @__PURE__ */ jsx(StatusIcon, { path: iconPath, className: iconClasses }) }),
-    hasContent && /* @__PURE__ */ jsxs("div", { className: alertContentClasses, children: [
-      hasTitle && /* @__PURE__ */ jsx("div", { className: titleClasses, children: titleSlot || title }),
-      hasDescription && /* @__PURE__ */ jsx("div", { className: descriptionClasses, children: descriptionSlot || description }),
-      hasDefaultContent && /* @__PURE__ */ jsx("div", { className: titleClasses, children })
-    ] }),
-    closable && /* @__PURE__ */ jsx(
-      "button",
-      {
-        className: closeButtonClasses,
-        onClick: handleClose,
-        "aria-label": closeAriaLabel,
-        type: "button",
-        children: /* @__PURE__ */ jsx(StatusIcon, { path: alertCloseIconPath, className: "h-4 w-4" })
-      }
-    ),
-    showCountdown && duration && duration > 0 && closable && /* @__PURE__ */ jsx("div", { className: alertCountdownContainerClasses, children: /* @__PURE__ */ jsx(
-      "div",
-      {
-        className: classNames(alertCountdownBarClasses, alertCountdownColorClasses[type]),
-        style: { width: `${countdownProgress}%` }
-      }
-    ) })
-  ] });
-};
-
-export {
-  Alert
-};