@expcat/tigercat-react 1.1.0 → 1.2.0

package/dist/chunk-UPPHGL64.js

@@ -0,0 +1,454 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/components/Form.tsx
+
+
+
+
+
+
+
+
+var _react = require('react'); var _react2 = _interopRequireDefault(_react);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _tigercatcore = require('@expcat/tigercat-core');
+var _jsxruntime = require('react/jsx-runtime');
+var FormContext = _react.createContext.call(void 0, null);
+var useFormContext = () => {
+  const context = _react.useContext.call(void 0, FormContext);
+  return context;
+};
+var Form = _react.forwardRef.call(void 0, 
+  ({
+    model = {},
+    rules,
+    labelWidth,
+    labelPosition = "right",
+    labelAlign = "right",
+    size = "md",
+    inlineMessage = true,
+    showRequiredAsterisk = true,
+    disabled = false,
+    loading = false,
+    children,
+    onSubmit,
+    onValidate,
+    onChange,
+    className,
+    fieldDependencies,
+    conditions,
+    validateDebounce = 0,
+    undoable = false,
+    maxHistorySize = 50,
+    ...props
+  }, ref) => {
+    const [errors, setErrors] = _react.useState.call(void 0, []);
+    const [formValues, setFormValues] = _react.useState.call(void 0, model);
+    const fieldRulesRef = _react2.default.useRef({});
+    const fieldConditionsRef = _react2.default.useRef({});
+    const formValuesRef = _react2.default.useRef(model);
+    const validationDebouncerRef = _react2.default.useRef(
+      _tigercatcore.createFormValidationDebouncer.call(void 0, { delay: validateDebounce })
+    );
+    const errorsByField = _react.useMemo.call(void 0, () => _tigercatcore.createFormErrorMap.call(void 0, errors), [errors]);
+    const [historyState, setHistoryState] = _react.useState.call(void 0, () => _tigercatcore.createFormHistory.call(void 0, model, maxHistorySize));
+    _react2.default.useEffect(() => {
+      setFormValues(model);
+    }, [model]);
+    _react2.default.useEffect(() => {
+      validationDebouncerRef.current.cancel();
+      validationDebouncerRef.current = _tigercatcore.createFormValidationDebouncer.call(void 0, { delay: validateDebounce });
+      return () => validationDebouncerRef.current.cancel();
+    }, [validateDebounce]);
+    formValuesRef.current = model;
+    const registerFieldRules = _react.useCallback.call(void 0, 
+      (fieldName, nextRules) => {
+        if (!fieldName) {
+          return;
+        }
+        if (!nextRules) {
+          delete fieldRulesRef.current[fieldName];
+          return;
+        }
+        fieldRulesRef.current[fieldName] = nextRules;
+      },
+      []
+    );
+    const registerFieldCondition = _react.useCallback.call(void 0, 
+      (fieldName, condition) => {
+        if (!fieldName) {
+          return;
+        }
+        if (!condition) {
+          delete fieldConditionsRef.current[fieldName];
+          return;
+        }
+        fieldConditionsRef.current[fieldName] = condition;
+      },
+      []
+    );
+    const getEffectiveConditions = _react.useCallback.call(void 0, () => {
+      const merged = { ..._nullishCoalesce(conditions, () => ( {})), ...fieldConditionsRef.current };
+      return Object.keys(merged).length > 0 ? merged : void 0;
+    }, [conditions]);
+    const getMergedFieldCondition = _react.useCallback.call(void 0, 
+      (fieldName, conditionOverride) => {
+        const base = _optionalChain([getEffectiveConditions, 'call', _2 => _2(), 'optionalAccess', _3 => _3[fieldName]]);
+        return base || conditionOverride ? { ..._nullishCoalesce(base, () => ( {})), ..._nullishCoalesce(conditionOverride, () => ( {})) } : void 0;
+      },
+      [getEffectiveConditions]
+    );
+    const getFieldConditionState = _react.useCallback.call(void 0, 
+      (fieldName, conditionOverride) => {
+        return _tigercatcore.resolveFormFieldConditionState.call(void 0, 
+          formValuesRef.current,
+          getMergedFieldCondition(fieldName, conditionOverride)
+        );
+      },
+      [getMergedFieldCondition]
+    );
+    const getEffectiveRules = _react.useCallback.call(void 0, () => {
+      const fromForm = _nullishCoalesce(rules, () => ( {}));
+      const fromItems = fieldRulesRef.current;
+      const merged = { ...fromForm, ...fromItems };
+      const nextRules = Object.keys(merged).length > 0 ? merged : void 0;
+      return _tigercatcore.resolveConditionalFormRules.call(void 0, formValuesRef.current, nextRules, getEffectiveConditions());
+    }, [rules, getEffectiveConditions]);
+    const resolveFieldRules = _react.useCallback.call(void 0, 
+      (fieldName, rulesOverride) => {
+        const fieldRules = _nullishCoalesce(_nullishCoalesce(rulesOverride, () => ( fieldRulesRef.current[fieldName])), () => ( _optionalChain([rules, 'optionalAccess', _4 => _4[fieldName]])));
+        const resolved = _tigercatcore.resolveConditionalFormRules.call(void 0, 
+          formValuesRef.current,
+          fieldRules ? { [fieldName]: fieldRules } : void 0,
+          getEffectiveConditions()
+        );
+        return _optionalChain([resolved, 'optionalAccess', _5 => _5[fieldName]]);
+      },
+      [rules, getEffectiveConditions]
+    );
+    const getDependencyMap = _react.useCallback.call(void 0, () => {
+      const conditionDependencies = _tigercatcore.createFormConditionDependencies.call(void 0, getEffectiveConditions());
+      if (!fieldDependencies && conditionDependencies.size === 0) {
+        return void 0;
+      }
+      const merged = new Map(_nullishCoalesce(fieldDependencies, () => ( [])));
+      for (const [fieldName, dependencies] of conditionDependencies.entries()) {
+        const current = _nullishCoalesce(merged.get(fieldName), () => ( []));
+        merged.set(fieldName, Array.from(/* @__PURE__ */ new Set([...current, ...dependencies])));
+      }
+      return merged;
+    }, [fieldDependencies, getEffectiveConditions]);
+    const runFieldValidation = _react.useCallback.call(void 0, 
+      async (fieldName, rulesOverride, trigger) => {
+        const fieldRules = resolveFieldRules(fieldName, rulesOverride);
+        if (!fieldRules) {
+          return null;
+        }
+        const currentValues = formValuesRef.current;
+        const value = _tigercatcore.getValueByPath.call(void 0, currentValues, fieldName);
+        return _tigercatcore.validateField.call(void 0, fieldName, value, fieldRules, currentValues, trigger);
+      },
+      [resolveFieldRules]
+    );
+    const validateFieldNow = _react.useCallback.call(void 0, 
+      async (fieldName, rulesOverride, trigger) => {
+        const conditionState = getFieldConditionState(fieldName);
+        if (!conditionState.shown || conditionState.disabled) {
+          setErrors((prevErrors) => prevErrors.filter((error) => error.field !== fieldName));
+          _optionalChain([onValidate, 'optionalCall', _6 => _6(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 = _nullishCoalesce(_optionalChain([existing, 'optionalAccess', _7 => _7.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;
+          });
+          _optionalChain([onValidate, 'optionalCall', _8 => _8(fieldName, !error, error)]);
+        }
+        const dependencyMap = getDependencyMap();
+        if (dependencyMap) {
+          const dependents = _tigercatcore.getDependentFields.call(void 0, fieldName, dependencyMap);
+          for (const dep of dependents) {
+            await validateFieldNow(dep);
+          }
+        }
+      },
+      [resolveFieldRules, runFieldValidation, onValidate, getFieldConditionState, getDependencyMap]
+    );
+    const validateField = _react.useCallback.call(void 0, 
+      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 = _react.useCallback.call(void 0, async () => {
+      validationDebouncerRef.current.cancel();
+      const effectiveRules = getEffectiveRules();
+      if (!effectiveRules) {
+        setErrors([]);
+        return { valid: true, errors: [] };
+      }
+      const result = await _tigercatcore.validateForm.call(void 0, formValuesRef.current, effectiveRules);
+      setErrors(result.errors);
+      return result;
+    }, [getEffectiveRules]);
+    const validate = _react.useCallback.call(void 0, async () => {
+      const result = await runValidation();
+      return result.valid;
+    }, [runValidation]);
+    const validateFields = _react.useCallback.call(void 0, 
+      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) {
+            _optionalChain([onValidate, 'optionalCall', _9 => _9(fieldName, true, null)]);
+            continue;
+          }
+          const error = await runFieldValidation(fieldName);
+          if (error) {
+            nextErrors.push({ field: fieldName, message: error });
+          }
+          _optionalChain([onValidate, 'optionalCall', _10 => _10(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.call(void 0, (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 = _react.useCallback.call(void 0, () => {
+      clearValidate();
+      setFormValues(model);
+    }, [model, clearValidate]);
+    const addField = _react.useCallback.call(void 0, 
+      (fieldName, defaultValue) => {
+        if (!fieldName) return;
+        setFormValues((prev) => {
+          const next = { ...prev, [fieldName]: _nullishCoalesce(defaultValue, () => ( null)) };
+          _optionalChain([onChange, 'optionalCall', _11 => _11(next)]);
+          return next;
+        });
+      },
+      [onChange]
+    );
+    const removeField = _react.useCallback.call(void 0, 
+      (fieldName) => {
+        if (!fieldName) return;
+        setFormValues((prev) => {
+          const { [fieldName]: _, ...next } = prev;
+          _optionalChain([onChange, 'optionalCall', _12 => _12(next)]);
+          return next;
+        });
+        clearValidate(fieldName);
+      },
+      [onChange, clearValidate]
+    );
+    const updateValue = _react.useCallback.call(void 0, 
+      (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);
+          _optionalChain([onChange, 'optionalCall', _13 => _13(newValues)]);
+          return newValues;
+        });
+      },
+      [onChange]
+    );
+    const snapshotHistory = _react.useCallback.call(void 0, () => {
+      if (!undoable) return;
+      setHistoryState((prev) => _tigercatcore.pushFormHistory.call(void 0, prev, formValuesRef.current));
+    }, [undoable]);
+    const undo = _react.useCallback.call(void 0, () => {
+      if (!undoable) return;
+      setHistoryState((prev) => {
+        const result = _tigercatcore.undoFormHistory.call(void 0, prev);
+        if (result) {
+          setFormValues(result.present);
+          formValuesRef.current = result.present;
+          _optionalChain([onChange, 'optionalCall', _14 => _14(result.present)]);
+          return result;
+        }
+        return prev;
+      });
+    }, [undoable, onChange]);
+    const redo = _react.useCallback.call(void 0, () => {
+      if (!undoable) return;
+      setHistoryState((prev) => {
+        const result = _tigercatcore.redoFormHistory.call(void 0, prev);
+        if (result) {
+          setFormValues(result.present);
+          formValuesRef.current = result.present;
+          _optionalChain([onChange, 'optionalCall', _15 => _15(result.present)]);
+          return result;
+        }
+        return prev;
+      });
+    }, [undoable, onChange]);
+    const handleSubmit = _react.useCallback.call(void 0, 
+      async (event) => {
+        event.preventDefault();
+        if (loading) return;
+        const result = await runValidation();
+        _optionalChain([onSubmit, 'optionalCall', _16 => _16({ ...result, values: formValuesRef.current })]);
+      },
+      [runValidation, onSubmit, loading]
+    );
+    _react.useImperativeHandle.call(void 0, 
+      ref,
+      () => ({
+        validate,
+        validateFields,
+        validateField,
+        clearValidate,
+        resetFields,
+        addField,
+        removeField,
+        undo,
+        redo,
+        snapshotHistory,
+        canUndo: _tigercatcore.canUndo.call(void 0, historyState),
+        canRedo: _tigercatcore.canRedo.call(void 0, historyState)
+      }),
+      [
+        validate,
+        validateFields,
+        validateField,
+        clearValidate,
+        resetFields,
+        addField,
+        removeField,
+        undo,
+        redo,
+        snapshotHistory,
+        historyState
+      ]
+    );
+    const contextValue = _react.useMemo.call(void 0, 
+      () => ({
+        model: formValues,
+        rules,
+        labelWidth,
+        labelPosition,
+        labelAlign,
+        size,
+        inlineMessage,
+        showRequiredAsterisk,
+        disabled,
+        loading,
+        errors,
+        errorsByField,
+        registerFieldRules,
+        registerFieldCondition,
+        getFieldConditionState,
+        validateField,
+        clearValidate,
+        updateValue
+      }),
+      [
+        formValues,
+        rules,
+        labelWidth,
+        labelPosition,
+        labelAlign,
+        size,
+        inlineMessage,
+        showRequiredAsterisk,
+        disabled,
+        loading,
+        errors,
+        errorsByField,
+        registerFieldRules,
+        registerFieldCondition,
+        getFieldConditionState,
+        validateField,
+        clearValidate,
+        updateValue
+      ]
+    );
+    const formClasses = _tigercatcore.classNames.call(void 0, 
+      "tiger-form",
+      `tiger-form--label-${labelPosition}`,
+      disabled && "tiger-form--disabled",
+      loading && "tiger-form--loading",
+      className
+    );
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, FormContext.Provider, { value: contextValue, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "form", { className: formClasses, onSubmit: handleSubmit, ...props, children }) });
+  }
+);
+Form.displayName = "TigerForm";
+
+
+
+
+exports.useFormContext = useFormContext; exports.Form = Form;

package/dist/chunk-UPQGB5NQ.mjs

@@ -1,8 +1,13 @@
-import { useMemo } from 'react';
-import { getPrintLayoutClasses, printLayoutHeaderClasses, printLayoutFooterClasses, classNames, printLayoutPageBreakClasses } from '@expcat/tigercat-core';
-import { jsx, jsxs } from 'react/jsx-runtime';
-
 // src/components/PrintLayout.tsx
+import { useMemo } from "react";
+import {
+  classNames,
+  getPrintLayoutClasses,
+  printLayoutHeaderClasses,
+  printLayoutFooterClasses,
+  printLayoutPageBreakClasses
+} from "@expcat/tigercat-core";
+import { jsx, jsxs } from "react/jsx-runtime";
 var PrintLayout = ({
   pageSize = "A4",
   orientation = "portrait",
@@ -35,4 +40,7 @@ var PrintPageBreak = (props) => /* @__PURE__ */ jsx(
   }
 );
 
-export { PrintLayout, PrintPageBreak };
+export {
+  PrintLayout,
+  PrintPageBreak
+};

package/dist/chunk-UQMPEMY7.mjs

@@ -1,6 +1,5 @@
-import { useState } from 'react';
-
 // src/hooks/useControlledState.ts
+import { useState } from "react";
 function useControlledState(controlledValue, defaultValue) {
   const [internalValue, setInternalValue] = useState(defaultValue);
   const isControlled = controlledValue !== void 0;
@@ -8,4 +7,6 @@ function useControlledState(controlledValue, defaultValue) {
   return [value, setInternalValue, isControlled];
 }
 
-export { useControlledState };
+export {
+  useControlledState
+};

package/dist/{chunk-36ATCHP4.js → chunk-UVMQJOTX.js}

@@ -1,11 +1,8 @@
-'use strict';
-
-var react = require('react');
-var reactDom = require('react-dom');
-var tigercatCore = require('@expcat/tigercat-core');
-var jsxRuntime = require('react/jsx-runtime');
-
-// src/components/ChartTooltip.tsx
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/components/ChartTooltip.tsx
+var _react = require('react');
+var _reactdom = require('react-dom');
+var _tigercatcore = require('@expcat/tigercat-core');
+var _jsxruntime = require('react/jsx-runtime');
 var ChartTooltip = ({
   content,
   visible = false,
@@ -13,9 +10,9 @@ var ChartTooltip = ({
   y = 0,
   className
 }) => {
-  const tooltipRef = react.useRef(null);
-  const [adjustedPosition, setAdjustedPosition] = react.useState({ x, y });
-  react.useEffect(() => {
+  const tooltipRef = _react.useRef.call(void 0, null);
+  const [adjustedPosition, setAdjustedPosition] = _react.useState.call(void 0, { x, y });
+  _react.useEffect.call(void 0, () => {
     if (!visible) return;
     let newX = x + 12;
     let newY = y - 8;
@@ -37,8 +34,8 @@ var ChartTooltip = ({
     setAdjustedPosition({ x: newX, y: newY });
     return () => cancelAnimationFrame(frameHandle);
   }, [x, y, visible]);
-  const tooltipClasses = react.useMemo(
-    () => tigercatCore.classNames(
+  const tooltipClasses = _react.useMemo.call(void 0, 
+    () => _tigercatcore.classNames.call(void 0, 
       "fixed left-0 top-0 z-[9999] pointer-events-none will-change-transform",
       "px-3 py-2 rounded-[var(--tiger-radius-md,0.375rem)] shadow-[var(--tiger-shadow-glass,0_10px_15px_-3px_rgb(0_0_0_/_0.1),0_4px_6px_-4px_rgb(0_0_0_/_0.1))]",
       "bg-[color:var(--tiger-bg-elevated,#1f2937)]",
@@ -51,25 +48,27 @@ var ChartTooltip = ({
     [visible, className]
   );
   if (!content) return null;
-  const tooltip = /* @__PURE__ */ jsxRuntime.jsx(
+  const tooltip = /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
     "div",
     {
       ref: tooltipRef,
       className: tooltipClasses,
       style: {
-        transform: tigercatCore.getChartTooltipTransform(adjustedPosition)
+        transform: _tigercatcore.getChartTooltipTransform.call(void 0, adjustedPosition)
       },
       role: "tooltip",
       "data-chart-tooltip": "true",
       children: content
     }
   );
-  if (typeof document !== "undefined") {
-    return reactDom.createPortal(tooltip, document.body);
+  if (_tigercatcore.isBrowser.call(void 0, )) {
+    return _reactdom.createPortal.call(void 0, tooltip, document.body);
   }
   return null;
 };
 var ChartTooltip_default = ChartTooltip;
 
-exports.ChartTooltip = ChartTooltip;
-exports.ChartTooltip_default = ChartTooltip_default;
+
+
+
+exports.ChartTooltip = ChartTooltip; exports.ChartTooltip_default = ChartTooltip_default;