@1money/react-ui 1.16.0 → 1.17.0

package/es/components/InputAmount/helper.d.ts

@@ -0,0 +1,46 @@
+export declare const MIN_INPUT_WIDTH = 33;
+export declare const DECIMAL_POINT_OFFSET = 2;
+export declare const SKELETON_LABEL_WIDTH = "72px";
+export declare const SKELETON_LABEL_HEIGHT = "18px";
+export declare const SPINNER_STROKE_WIDTH = "4";
+export declare const CSS_VAR_INPUT_WIDTH = "--input-width";
+export declare const DEFAULT_TYPE: "primary";
+export declare const DEFAULT_SIZE: "large";
+export declare const DEFAULT_PLACEHOLDER = "0";
+export declare const DEFAULT_PREFIX_CLS = "input-amount";
+export declare const CHAR_MINUS = "-";
+export declare const CHAR_DOT = ".";
+export declare const CHAR_COMMA = ",";
+export declare const isNumericType: (val: unknown) => val is number | bigint;
+export declare const normalizeNumberInput: (val: string) => string;
+export declare const stripCommas: (val: string) => string;
+export declare const stripMinus: (val: string) => string;
+export declare const formatThousands: (val: string, allowNegative?: boolean) => string;
+export declare const calcValueInRange: (val: string, min?: number | bigint, max?: number | bigint) => string;
+/**
+ * Normalize a raw numeric value string:
+ * - Strips leading zeros via BigNumber
+ * - Preserves negative-zero representation when applicable
+ * - Appends trailing decimal point if present in input
+ */
+export declare const normalizeValue: (val: string, hasDecimalPoint: boolean, negative?: boolean) => string;
+export declare const truncateFractionDigits: (val: string, maxDecimals: number) => {
+    int: string;
+    truncated: string;
+    overflow: boolean;
+};
+export declare const calcGapWidth: (hasPrefix: boolean, hasSuffix: boolean, hasCurrency: boolean) => 0 | 8 | 16 | 24;
+export interface ParsedInput {
+    val: string;
+    hasDecimalPoint: boolean;
+    isStandaloneMinus: boolean;
+}
+/**
+ * Parse and sanitize a raw string input value.
+ * Returns `null` if the value is invalid and should be rejected.
+ */
+export declare const parseRawInput: (raw: string, negative?: boolean) => ParsedInput | null;
+/**
+ * Ensure a numeric value is non-negative when `negative` is not allowed.
+ */
+export declare const absValue: (val: number | bigint) => number | bigint;

package/es/components/InputAmount/helper.js

@@ -0,0 +1,115 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import BigNumber from 'bignumber.js';
+import { numericFormatter } from 'react-number-format';
+export var MIN_INPUT_WIDTH = 33;
+export var DECIMAL_POINT_OFFSET = 2;
+export var SKELETON_LABEL_WIDTH = '72px';
+export var SKELETON_LABEL_HEIGHT = '18px';
+export var SPINNER_STROKE_WIDTH = '4';
+export var CSS_VAR_INPUT_WIDTH = '--input-width';
+export var DEFAULT_TYPE = 'primary';
+export var DEFAULT_SIZE = 'large';
+export var DEFAULT_PLACEHOLDER = '0';
+export var DEFAULT_PREFIX_CLS = 'input-amount';
+export var CHAR_MINUS = '-';
+export var CHAR_DOT = '.';
+export var CHAR_COMMA = ',';
+var GAP_SINGLE = 8;
+var GAP_DOUBLE = 16;
+var GAP_TRIPLE = 24;
+/** Fullwidth decimal/period → ASCII dot, fullwidth comma → ASCII comma */
+var FULLWIDTH_DOT_RE = /[\u3002\uff0e\uff61]/g;
+var FULLWIDTH_COMMA_RE = /[\uFF0C]/g;
+var MINUS_RE = /-/g;
+var TRAILING_DECIMALS_RE = /\.(\d+)$/;
+export var isNumericType = function isNumericType(val) {
+  return typeof val === 'number' || typeof val === 'bigint';
+};
+export var normalizeNumberInput = function normalizeNumberInput(val) {
+  return val.replace(FULLWIDTH_DOT_RE, CHAR_DOT).replace(FULLWIDTH_COMMA_RE, CHAR_COMMA);
+};
+export var stripCommas = function stripCommas(val) {
+  return val.split(CHAR_COMMA).join('');
+};
+export var stripMinus = function stripMinus(val) {
+  return val.replace(MINUS_RE, '');
+};
+export var formatThousands = function formatThousands(val, allowNegative) {
+  return numericFormatter(val, {
+    thousandSeparator: true,
+    allowNegative: allowNegative
+  });
+};
+export var calcValueInRange = function calcValueInRange(val, min, max) {
+  if (val === '' || val === CHAR_MINUS || isNaN(+val)) return val;
+  var bnVal = BigNumber(val);
+  if (isNumericType(min) && bnVal.lt(BigNumber(min))) return "".concat(min);
+  if (isNumericType(max) && bnVal.gt(BigNumber(max))) return "".concat(max);
+  return val;
+};
+/**
+ * Normalize a raw numeric value string:
+ * - Strips leading zeros via BigNumber
+ * - Preserves negative-zero representation when applicable
+ * - Appends trailing decimal point if present in input
+ */
+export var normalizeValue = function normalizeValue(val, hasDecimalPoint, negative) {
+  var _a, _b, _c;
+  var decimals = (_c = (_b = (_a = val.match(TRAILING_DECIMALS_RE)) === null || _a === void 0 ? void 0 : _a[1]) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0;
+  var bn = BigNumber(val);
+  var normalized = bn.toFixed(decimals);
+  if (negative && val.trim().startsWith(CHAR_MINUS) && bn.isZero()) {
+    normalized = normalized.startsWith(CHAR_MINUS) ? normalized : "".concat(CHAR_MINUS).concat(normalized);
+  }
+  return "".concat(normalized).concat(hasDecimalPoint ? CHAR_DOT : '').trim();
+};
+export var truncateFractionDigits = function truncateFractionDigits(val, maxDecimals) {
+  var _val$split = val.split(CHAR_DOT),
+    _val$split2 = _slicedToArray(_val$split, 2),
+    _int = _val$split2[0],
+    decimal = _val$split2[1];
+  if (decimal != null && decimal.length > maxDecimals) {
+    return {
+      "int": _int,
+      truncated: "".concat(_int).concat(CHAR_DOT).concat(decimal.slice(0, maxDecimals)),
+      overflow: true
+    };
+  }
+  return {
+    "int": _int,
+    truncated: val,
+    overflow: false
+  };
+};
+export var calcGapWidth = function calcGapWidth(hasPrefix, hasSuffix, hasCurrency) {
+  var count = +hasPrefix + +hasSuffix + +hasCurrency;
+  if (count >= 3) return GAP_TRIPLE;
+  if (count === 2) return GAP_DOUBLE;
+  if (count === 1) return GAP_SINGLE;
+  return 0;
+};
+/**
+ * Parse and sanitize a raw string input value.
+ * Returns `null` if the value is invalid and should be rejected.
+ */
+export var parseRawInput = function parseRawInput(raw, negative) {
+  var val = stripCommas(normalizeNumberInput(raw));
+  var hasDecimalPoint = val.endsWith(CHAR_DOT);
+  if (hasDecimalPoint) val = val.slice(0, -1);
+  if (!negative && val.includes(CHAR_MINUS)) return null;
+  var isStandaloneMinus = !!negative && val === CHAR_MINUS;
+  if (!isStandaloneMinus && isNaN(+val)) return null;
+  return {
+    val: val,
+    hasDecimalPoint: hasDecimalPoint,
+    isStandaloneMinus: isStandaloneMinus
+  };
+};
+/**
+ * Ensure a numeric value is non-negative when `negative` is not allowed.
+ */
+export var absValue = function absValue(val) {
+  if (typeof val === 'number') return Math.abs(val);
+  return val < BigInt(0) ? -val : val;
+};
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/src/components/InputAmount/helper.ts","components/InputAmount/helper.js"],"names":["BigNumber","numericFormatter","MIN_INPUT_WIDTH","DECIMAL_POINT_OFFSET","SKELETON_LABEL_WIDTH","SKELETON_LABEL_HEIGHT","SPINNER_STROKE_WIDTH","CSS_VAR_INPUT_WIDTH","DEFAULT_TYPE","DEFAULT_SIZE","DEFAULT_PLACEHOLDER","DEFAULT_PREFIX_CLS","CHAR_MINUS","CHAR_DOT","CHAR_COMMA","GAP_SINGLE","GAP_DOUBLE","GAP_TRIPLE","FULLWIDTH_DOT_RE","FULLWIDTH_COMMA_RE","MINUS_RE","TRAILING_DECIMALS_RE","isNumericType","val","normalizeNumberInput","replace","stripCommas","split","join","stripMinus","formatThousands","allowNegative","thousandSeparator","calcValueInRange","min","max","isNaN","bnVal","lt","concat","gt","normalizeValue","hasDecimalPoint","negative","_a","_b","_c","decimals","match","length","bn","normalized","toFixed","trim","startsWith","isZero","truncateFractionDigits","maxDecimals","_val$split","_val$split2","_slicedToArray","int","decimal","truncated","slice","overflow","calcGapWidth","hasPrefix","hasSuffix","hasCurrency","count","parseRawInput","raw","endsWith","includes","isStandaloneMinus","absValue","Math","abs","BigInt"],"mappings":"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","file":"components/InputAmount/helper.js","sourcesContent":[null,"import BigNumber from 'bignumber.js';\nimport { numericFormatter } from 'react-number-format';\nexport const MIN_INPUT_WIDTH = 33;\nexport const DECIMAL_POINT_OFFSET = 2;\nexport const SKELETON_LABEL_WIDTH = '72px';\nexport const SKELETON_LABEL_HEIGHT = '18px';\nexport const SPINNER_STROKE_WIDTH = '4';\nexport const CSS_VAR_INPUT_WIDTH = '--input-width';\nexport const DEFAULT_TYPE = 'primary';\nexport const DEFAULT_SIZE = 'large';\nexport const DEFAULT_PLACEHOLDER = '0';\nexport const DEFAULT_PREFIX_CLS = 'input-amount';\nexport const CHAR_MINUS = '-';\nexport const CHAR_DOT = '.';\nexport const CHAR_COMMA = ',';\nconst GAP_SINGLE = 8;\nconst GAP_DOUBLE = 16;\nconst GAP_TRIPLE = 24;\n/** Fullwidth decimal/period → ASCII dot, fullwidth comma → ASCII comma */\nconst FULLWIDTH_DOT_RE = /[\\u3002\\uff0e\\uff61]/g;\nconst FULLWIDTH_COMMA_RE = /[\\uFF0C]/g;\nconst MINUS_RE = /-/g;\nconst TRAILING_DECIMALS_RE = /\\.(\\d+)$/;\nexport const isNumericType = (val) => typeof val === 'number' || typeof val === 'bigint';\nexport const normalizeNumberInput = (val) => val\n    .replace(FULLWIDTH_DOT_RE, CHAR_DOT)\n    .replace(FULLWIDTH_COMMA_RE, CHAR_COMMA);\nexport const stripCommas = (val) => val.split(CHAR_COMMA).join('');\nexport const stripMinus = (val) => val.replace(MINUS_RE, '');\nexport const formatThousands = (val, allowNegative) => numericFormatter(val, { thousandSeparator: true, allowNegative });\nexport const calcValueInRange = (val, min, max) => {\n    if (val === '' || val === CHAR_MINUS || isNaN(+val))\n        return val;\n    const bnVal = BigNumber(val);\n    if (isNumericType(min) && bnVal.lt(BigNumber(min)))\n        return `${min}`;\n    if (isNumericType(max) && bnVal.gt(BigNumber(max)))\n        return `${max}`;\n    return val;\n};\n/**\n * Normalize a raw numeric value string:\n * - Strips leading zeros via BigNumber\n * - Preserves negative-zero representation when applicable\n * - Appends trailing decimal point if present in input\n */\nexport const normalizeValue = (val, hasDecimalPoint, negative) => {\n    var _a, _b, _c;\n    const decimals = (_c = (_b = (_a = val.match(TRAILING_DECIMALS_RE)) === null || _a === void 0 ? void 0 : _a[1]) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0;\n    const bn = BigNumber(val);\n    let normalized = bn.toFixed(decimals);\n    if (negative && val.trim().startsWith(CHAR_MINUS) && bn.isZero()) {\n        normalized = normalized.startsWith(CHAR_MINUS) ? normalized : `${CHAR_MINUS}${normalized}`;\n    }\n    return `${normalized}${hasDecimalPoint ? CHAR_DOT : ''}`.trim();\n};\nexport const truncateFractionDigits = (val, maxDecimals) => {\n    const [int, decimal] = val.split(CHAR_DOT);\n    if (decimal != null && decimal.length > maxDecimals) {\n        return { int, truncated: `${int}${CHAR_DOT}${decimal.slice(0, maxDecimals)}`, overflow: true };\n    }\n    return { int, truncated: val, overflow: false };\n};\nexport const calcGapWidth = (hasPrefix, hasSuffix, hasCurrency) => {\n    const count = +hasPrefix + +hasSuffix + +hasCurrency;\n    if (count >= 3)\n        return GAP_TRIPLE;\n    if (count === 2)\n        return GAP_DOUBLE;\n    if (count === 1)\n        return GAP_SINGLE;\n    return 0;\n};\n/**\n * Parse and sanitize a raw string input value.\n * Returns `null` if the value is invalid and should be rejected.\n */\nexport const parseRawInput = (raw, negative) => {\n    let val = stripCommas(normalizeNumberInput(raw));\n    const hasDecimalPoint = val.endsWith(CHAR_DOT);\n    if (hasDecimalPoint)\n        val = val.slice(0, -1);\n    if (!negative && val.includes(CHAR_MINUS))\n        return null;\n    const isStandaloneMinus = !!negative && val === CHAR_MINUS;\n    if (!isStandaloneMinus && isNaN(+val))\n        return null;\n    return { val, hasDecimalPoint, isStandaloneMinus };\n};\n/**\n * Ensure a numeric value is non-negative when `negative` is not allowed.\n */\nexport const absValue = (val) => {\n    if (typeof val === 'number')\n        return Math.abs(val);\n    return val < BigInt(0) ? -val : val;\n};"],"sourceRoot":"../../../../../../../../../src"}

package/es/components/ProForm/ProForm.d.ts

@@ -0,0 +1,33 @@
+import type { FieldValues } from 'react-hook-form';
+import type { ProFormProps } from './interface';
+/** Context value providing ProForm-level configuration to descendant field components. */
+export interface ProFormContextValue {
+    /** Whether all fields should render in readonly mode. */
+    readonly?: boolean;
+    /** Whether grid layout is enabled. */
+    grid?: boolean;
+    /** Default column props for grid fields. */
+    colProps?: {
+        span?: number;
+    };
+}
+/**
+ * React context that propagates ProForm configuration (readonly, grid, colProps)
+ * to nested field components created via {@link createProFormField}.
+ */
+export declare const ProFormContext: import("react").Context<ProFormContextValue>;
+/**
+ * Enhanced form component with built-in submit/reset buttons, grid layout,
+ * readonly mode, and async remote data loading via `request`.
+ *
+ * @typeParam TFieldValues - The form values type.
+ *
+ * @example
+ * ```tsx
+ * <ProForm onFinish={async (values) => { await save(values); }}>
+ *   <ProFormText name="username" label="Username" />
+ * </ProForm>
+ * ```
+ */
+export declare function ProForm<TFieldValues extends FieldValues = FieldValues>(props: ProFormProps<TFieldValues>): import("react/jsx-runtime").JSX.Element;
+export default ProForm;

package/es/components/ProForm/ProForm.js

@@ -0,0 +1,208 @@
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var __rest = this && this.__rest || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { createContext, useEffect, useMemo, useRef } from 'react';
+import useLatest from '../useLatest';
+import useMemoizedFn from '../useMemoizedFn';
+import { useForm } from 'react-hook-form';
+import { Row } from '../Grid';
+import { Form } from '../Form';
+import Submitter from './Submitter';
+import { DEFAULT_COL_SPAN } from './constants';
+import { isSubmitterEnabled, stableSerialize } from './utils';
+/**
+ * React context that propagates ProForm configuration (readonly, grid, colProps)
+ * to nested field components created via {@link createProFormField}.
+ */
+export var ProFormContext = /*#__PURE__*/createContext({
+  readonly: false,
+  grid: false,
+  colProps: {
+    span: DEFAULT_COL_SPAN
+  }
+});
+/**
+ * Enhanced form component with built-in submit/reset buttons, grid layout,
+ * readonly mode, and async remote data loading via `request`.
+ *
+ * @typeParam TFieldValues - The form values type.
+ *
+ * @example
+ * ```tsx
+ * <ProForm onFinish={async (values) => { await save(values); }}>
+ *   <ProFormText name="username" label="Username" />
+ * </ProForm>
+ * ```
+ */
+export function ProForm(props) {
+  var _this = this;
+  var _a, _b, _c, _d, _e, _f, _g;
+  var submitter = props.submitter,
+    _props$readonly = props.readonly,
+    readonly = _props$readonly === void 0 ? false : _props$readonly,
+    _props$grid = props.grid,
+    grid = _props$grid === void 0 ? false : _props$grid,
+    colProps = props.colProps,
+    rowProps = props.rowProps,
+    externalForm = props.form,
+    request = props.request,
+    params = props.params,
+    _props$loading = props.loading,
+    loading = _props$loading === void 0 ? false : _props$loading,
+    children = props.children,
+    onFinish = props.onFinish,
+    defaultValues = props.defaultValues,
+    rest = __rest(props, ["submitter", "readonly", "grid", "colProps", "rowProps", "form", "request", "params", "loading", "children", "onFinish", "defaultValues"]);
+  // Always create an internal form to keep hook ordering stable.
+  // When `externalForm` is provided, this instance is unused. We pass
+  // `shouldUnregister: true` to minimize overhead of the unused form.
+  var internalForm = useForm({
+    defaultValues: defaultValues,
+    shouldUnregister: true
+  });
+  var form = externalForm !== null && externalForm !== void 0 ? externalForm : internalForm;
+  var paramsKey = useMemo(function () {
+    return stableSerialize(params);
+  }, [params]);
+  var stableParams = useMemo(function () {
+    return params;
+  }, [paramsKey]);
+  var stableColProps = useMemo(function () {
+    return colProps !== null && colProps !== void 0 ? colProps : {
+      span: DEFAULT_COL_SPAN
+    };
+  }, [colProps === null || colProps === void 0 ? void 0 : colProps.span]);
+  var latestRequestRef = useLatest(request);
+  var latestResetValuesRef = useRef(defaultValues);
+  var formRest = rest;
+  var onFinishFailed = formRest.onFinishFailed,
+    forwardedFormProps = __rest(formRest, ["onFinishFailed"]);
+  useEffect(function () {
+    latestResetValuesRef.current = defaultValues;
+  }, [defaultValues]);
+  useEffect(function () {
+    var cancelled = false;
+    var currentRequest = latestRequestRef.current;
+    if (!currentRequest) return;
+    currentRequest(stableParams).then(function (values) {
+      if (cancelled || !values) return;
+      form.reset(values);
+      latestResetValuesRef.current = values;
+    })["catch"](function () {
+      // Silently ignore — consumers should handle request errors
+      // via their own error boundaries or by wrapping the `request` function.
+    });
+    return function () {
+      cancelled = true;
+    };
+  }, [stableParams, form]);
+  var ctx = useMemo(function () {
+    return {
+      readonly: readonly,
+      grid: grid,
+      colProps: stableColProps
+    };
+  }, [readonly, grid, stableColProps]);
+  var handleFinish = useMemoizedFn(function (values) {
+    return __awaiter(_this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return onFinish === null || onFinish === void 0 ? void 0 : onFinish(values);
+          case 2:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+  });
+  var handleReset = useMemoizedFn(function () {
+    var _a;
+    form.reset(latestResetValuesRef.current);
+    if (isSubmitterEnabled(submitter)) {
+      (_a = submitter.onReset) === null || _a === void 0 ? void 0 : _a.call(submitter);
+    }
+  });
+  var triggerSubmitterOnSubmit = useMemoizedFn(function () {
+    var _a;
+    if (isSubmitterEnabled(submitter)) {
+      (_a = submitter.onSubmit) === null || _a === void 0 ? void 0 : _a.call(submitter);
+    }
+  });
+  var handleSubmitFromRender = useMemoizedFn(function () {
+    triggerSubmitterOnSubmit();
+    try {
+      var submitPromise = form.handleSubmit(handleFinish, onFinishFailed)(undefined);
+      submitPromise["catch"](function (error) {
+        console.error('[ProForm] handleSubmitFromRender rejected after triggerSubmitterOnSubmit via form.handleSubmit(handleFinish, onFinishFailed).', error);
+      });
+    } catch (error) {
+      console.error('[ProForm] handleSubmitFromRender threw after triggerSubmitterOnSubmit via form.handleSubmit(handleFinish, onFinishFailed).', error);
+    }
+  });
+  var mergedDisabled = (_a = rest.disabled) !== null && _a !== void 0 ? _a : loading;
+  var content = !grid ? children : _jsx(Row, {
+    gutter: rowProps === null || rowProps === void 0 ? void 0 : rowProps.gutter,
+    children: children
+  });
+  return _jsx(ProFormContext.Provider, {
+    value: ctx,
+    children: _jsxs(Form, Object.assign({}, forwardedFormProps, {
+      form: form,
+      disabled: mergedDisabled,
+      defaultValues: defaultValues,
+      onFinish: handleFinish,
+      onFinishFailed: onFinishFailed,
+      children: [content, submitter !== false && _jsx(Submitter, Object.assign({}, submitter || {}, {
+        form: form,
+        submitButtonProps: Object.assign(Object.assign({}, (submitter === null || submitter === void 0 ? void 0 : submitter.submitButtonProps) || {}), {
+          loading: (_c = (_b = submitter === null || submitter === void 0 ? void 0 : submitter.submitButtonProps) === null || _b === void 0 ? void 0 : _b.loading) !== null && _c !== void 0 ? _c : loading,
+          disabled: (_e = (_d = submitter === null || submitter === void 0 ? void 0 : submitter.submitButtonProps) === null || _d === void 0 ? void 0 : _d.disabled) !== null && _e !== void 0 ? _e : loading
+        }),
+        resetButtonProps: Object.assign(Object.assign({}, (submitter === null || submitter === void 0 ? void 0 : submitter.resetButtonProps) || {}), {
+          disabled: (_g = (_f = submitter === null || submitter === void 0 ? void 0 : submitter.resetButtonProps) === null || _f === void 0 ? void 0 : _f.disabled) !== null && _g !== void 0 ? _g : loading
+        }),
+        onSubmit: triggerSubmitterOnSubmit,
+        onSubmitForm: handleSubmitFromRender,
+        onReset: handleReset
+      }))]
+    }))
+  });
+}
+export default ProForm;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/ProForm/ProForm.js","components/src/components/ProForm/ProForm.tsx"],"names":["__awaiter","thisArg","_arguments","P","generator","adopt","value","resolve","Promise","reject","fulfilled","step","next","e","rejected","result","done","then","apply","__rest","s","t","p","Object","prototype","hasOwnProperty","call","indexOf","getOwnPropertySymbols","i","length","propertyIsEnumerable","jsx","_jsx","jsxs","_jsxs","createContext","useEffect","useMemo","useRef","useLatest","useMemoizedFn","useForm","Row","Form","Submitter","DEFAULT_COL_SPAN","isSubmitterEnabled","stableSerialize","ProFormContext","readonly","grid","colProps","span","ProForm","props","_this","_a","_b","_c","_d","_e","_f","_g","submitter","_props$readonly","_props$grid","rowProps","externalForm","form","request","params","_props$loading","loading","children","onFinish","defaultValues","rest","internalForm","shouldUnregister","paramsKey","stableParams","stableColProps","latestRequestRef","latestResetValuesRef","formRest","onFinishFailed","forwardedFormProps","current","cancelled","currentRequest","values","reset","ctx","handleFinish","_regeneratorRuntime","mark","_callee","wrap","_callee$","_context","prev","stop","handleReset","onReset","triggerSubmitterOnSubmit","onSubmit","handleSubmitFromRender","submitPromise","handleSubmit","undefined","error","console","mergedDisabled","disabled","content","gutter","Provider","assign","submitButtonProps","resetButtonProps","onSubmitForm"],"mappings":"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","file":"components/ProForm/ProForm.js","sourcesContent":["var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __rest = (this && this.__rest) || function (s, e) {\n    var t = {};\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n        t[p] = s[p];\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n                t[p[i]] = s[p[i]];\n        }\n    return t;\n};\nimport { jsx as _jsx, jsxs as _jsxs } from \"react/jsx-runtime\";\nimport { createContext, useEffect, useMemo, useRef, } from 'react';\nimport useLatest from '../useLatest';\nimport useMemoizedFn from '../useMemoizedFn';\nimport { useForm } from 'react-hook-form';\nimport { Row } from '../Grid';\nimport { Form } from '../Form';\nimport Submitter from './Submitter';\nimport { DEFAULT_COL_SPAN } from './constants';\nimport { isSubmitterEnabled, stableSerialize } from './utils';\n/**\n * React context that propagates ProForm configuration (readonly, grid, colProps)\n * to nested field components created via {@link createProFormField}.\n */\nexport const ProFormContext = createContext({\n    readonly: false,\n    grid: false,\n    colProps: { span: DEFAULT_COL_SPAN },\n});\n/**\n * Enhanced form component with built-in submit/reset buttons, grid layout,\n * readonly mode, and async remote data loading via `request`.\n *\n * @typeParam TFieldValues - The form values type.\n *\n * @example\n * ```tsx\n * <ProForm onFinish={async (values) => { await save(values); }}>\n *   <ProFormText name=\"username\" label=\"Username\" />\n * </ProForm>\n * ```\n */\nexport function ProForm(props) {\n    var _a, _b, _c, _d, _e, _f, _g;\n    const { submitter, readonly = false, grid = false, colProps, rowProps, form: externalForm, request, params, loading = false, children, onFinish, defaultValues } = props, rest = __rest(props, [\"submitter\", \"readonly\", \"grid\", \"colProps\", \"rowProps\", \"form\", \"request\", \"params\", \"loading\", \"children\", \"onFinish\", \"defaultValues\"]);\n    // Always create an internal form to keep hook ordering stable.\n    // When `externalForm` is provided, this instance is unused. We pass\n    // `shouldUnregister: true` to minimize overhead of the unused form.\n    const internalForm = useForm({ defaultValues, shouldUnregister: true });\n    const form = externalForm !== null && externalForm !== void 0 ? externalForm : internalForm;\n    const paramsKey = useMemo(() => stableSerialize(params), [params]);\n    const stableParams = useMemo(() => params, [paramsKey]);\n    const stableColProps = useMemo(() => colProps !== null && colProps !== void 0 ? colProps : { span: DEFAULT_COL_SPAN }, [colProps === null || colProps === void 0 ? void 0 : colProps.span]);\n    const latestRequestRef = useLatest(request);\n    const latestResetValuesRef = useRef(defaultValues);\n    const formRest = rest;\n    const { onFinishFailed } = formRest, forwardedFormProps = __rest(formRest, [\"onFinishFailed\"]);\n    useEffect(() => {\n        latestResetValuesRef.current = defaultValues;\n    }, [defaultValues]);\n    useEffect(() => {\n        let cancelled = false;\n        const currentRequest = latestRequestRef.current;\n        if (!currentRequest)\n            return;\n        currentRequest(stableParams)\n            .then(values => {\n            if (cancelled || !values)\n                return;\n            form.reset(values);\n            latestResetValuesRef.current = values;\n        })\n            .catch(() => {\n            // Silently ignore — consumers should handle request errors\n            // via their own error boundaries or by wrapping the `request` function.\n        });\n        return () => {\n            cancelled = true;\n        };\n    }, [stableParams, form]);\n    const ctx = useMemo(() => ({\n        readonly,\n        grid,\n        colProps: stableColProps,\n    }), [readonly, grid, stableColProps]);\n    const handleFinish = useMemoizedFn((values) => __awaiter(this, void 0, void 0, function* () {\n        yield (onFinish === null || onFinish === void 0 ? void 0 : onFinish(values));\n    }));\n    const handleReset = useMemoizedFn(() => {\n        var _a;\n        form.reset(latestResetValuesRef.current);\n        if (isSubmitterEnabled(submitter)) {\n            (_a = submitter.onReset) === null || _a === void 0 ? void 0 : _a.call(submitter);\n        }\n    });\n    const triggerSubmitterOnSubmit = useMemoizedFn(() => {\n        var _a;\n        if (isSubmitterEnabled(submitter)) {\n            (_a = submitter.onSubmit) === null || _a === void 0 ? void 0 : _a.call(submitter);\n        }\n    });\n    const handleSubmitFromRender = useMemoizedFn(() => {\n        triggerSubmitterOnSubmit();\n        try {\n            const submitPromise = form.handleSubmit(handleFinish, onFinishFailed)(undefined);\n            submitPromise.catch((error) => {\n                console.error('[ProForm] handleSubmitFromRender rejected after triggerSubmitterOnSubmit via form.handleSubmit(handleFinish, onFinishFailed).', error);\n            });\n        }\n        catch (error) {\n            console.error('[ProForm] handleSubmitFromRender threw after triggerSubmitterOnSubmit via form.handleSubmit(handleFinish, onFinishFailed).', error);\n        }\n    });\n    const mergedDisabled = (_a = rest.disabled) !== null && _a !== void 0 ? _a : loading;\n    const content = !grid\n        ? children\n        : (_jsx(Row, { gutter: rowProps === null || rowProps === void 0 ? void 0 : rowProps.gutter, children: children }));\n    return (_jsx(ProFormContext.Provider, { value: ctx, children: _jsxs(Form, Object.assign({}, forwardedFormProps, { form: form, disabled: mergedDisabled, defaultValues: defaultValues, onFinish: handleFinish, onFinishFailed: onFinishFailed, children: [content, submitter !== false && (_jsx(Submitter, Object.assign({}, (submitter || {}), { form: form, submitButtonProps: Object.assign(Object.assign({}, ((submitter === null || submitter === void 0 ? void 0 : submitter.submitButtonProps) || {})), { loading: (_c = (_b = submitter === null || submitter === void 0 ? void 0 : submitter.submitButtonProps) === null || _b === void 0 ? void 0 : _b.loading) !== null && _c !== void 0 ? _c : loading, disabled: (_e = (_d = submitter === null || submitter === void 0 ? void 0 : submitter.submitButtonProps) === null || _d === void 0 ? void 0 : _d.disabled) !== null && _e !== void 0 ? _e : loading }), resetButtonProps: Object.assign(Object.assign({}, ((submitter === null || submitter === void 0 ? void 0 : submitter.resetButtonProps) || {})), { disabled: (_g = (_f = submitter === null || submitter === void 0 ? void 0 : submitter.resetButtonProps) === null || _f === void 0 ? void 0 : _f.disabled) !== null && _g !== void 0 ? _g : loading }), onSubmit: triggerSubmitterOnSubmit, onSubmitForm: handleSubmitFromRender, onReset: handleReset })))] })) }));\n}\nexport default ProForm;",null],"sourceRoot":"../../../../../../../../../src"}

package/es/components/ProForm/ProFormDependency.d.ts

@@ -0,0 +1,12 @@
+import type { ReactNode } from 'react';
+/**
+ * Props for {@link ProFormDependency}.
+ */
+export interface ProFormDependencyProps {
+    /** Field names to watch for changes. */
+    name: string[];
+    /** Render function that receives the watched field values as a keyed object. */
+    children: (values: Record<string, unknown>) => ReactNode;
+}
+export declare const ProFormDependency: import("react").NamedExoticComponent<ProFormDependencyProps>;
+export default ProFormDependency;

package/es/components/ProForm/ProFormDependency.js

@@ -0,0 +1,61 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { memo, useContext, useMemo } from 'react';
+import { useWatch } from 'react-hook-form';
+import { FormContext } from '../Form/Form';
+import { FallbackFormProvider, useFormItemContext } from '../Form/useFormItemContext';
+var __DEV__ = function () {
+  var _a, _b;
+  var maybeProcess = globalThis;
+  return ((_b = (_a = maybeProcess.process) === null || _a === void 0 ? void 0 : _a.env) === null || _b === void 0 ? void 0 : _b.NODE_ENV) !== 'production';
+}();
+var hasWarnedIsolatedDependency = false;
+/**
+ * Watches one or more form fields and re-renders its children whenever
+ * the watched values change. Useful for conditional field visibility or
+ * cross-field derived content.
+ *
+ * @example
+ * ```tsx
+ * <ProFormDependency name={['country']}>
+ *   {({ country }) => country === 'US' && <ProFormText name="state" label="State" />}
+ * </ProFormDependency>
+ * ```
+ */
+var ProFormDependencyInner = function ProFormDependencyInner(props) {
+  var name = props.name,
+    children = props.children;
+  var _useFormItemContext = useFormItemContext(),
+    methods = _useFormItemContext.methods;
+  var watchedValues = useWatch({
+    control: methods.control,
+    name: name
+  });
+  var values = useMemo(function () {
+    var names = name;
+    var list = watchedValues;
+    return names.reduce(function (acc, key, index) {
+      acc[key] = list[index];
+      return acc;
+    }, {});
+  }, [name, watchedValues]);
+  return _jsx(_Fragment, {
+    children: children(values)
+  });
+};
+var ProFormDependencyBase = function ProFormDependencyBase(props) {
+  var ctx = useContext(FormContext);
+  if (!(ctx === null || ctx === void 0 ? void 0 : ctx.methods)) {
+    if (__DEV__ && !hasWarnedIsolatedDependency) {
+      hasWarnedIsolatedDependency = true;
+      console.warn('[ProFormDependencyBase] Missing FormContext methods. Rendering with FallbackFormProvider. ' + 'ProFormDependencyInner will use an isolated form instance, and useWatch may return undefined ' + 'for watched fields when ProFormDependency is used outside a Form.');
+    }
+    return _jsx(FallbackFormProvider, {
+      children: _jsx(ProFormDependencyInner, Object.assign({}, props))
+    });
+  }
+  return _jsx(ProFormDependencyInner, Object.assign({}, props));
+};
+ProFormDependencyBase.displayName = 'ProFormDependency';
+export var ProFormDependency = /*#__PURE__*/memo(ProFormDependencyBase);
+export default ProFormDependency;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/es/components/ProForm/ProFormList.d.ts

@@ -0,0 +1,19 @@
+import type { DragEndEvent } from '@dnd-kit/core';
+import type { FieldValues } from 'react-hook-form';
+import type { ProFormListProps } from './interface';
+/**
+ * Creates a `DndContext` `onDragEnd` handler that translates drag events
+ * into field array `move` calls.
+ *
+ * @param options.move - The `move` function from `useFieldArray`.
+ * @param options.fields - The current field array entries.
+ * @returns A drag-end event handler.
+ */
+export declare const buildOnDragEnd: ({ move, fields, }: {
+    move: (from: number, to: number) => void;
+    fields: Array<{
+        id: string;
+    }>;
+}) => ({ active, over }: DragEndEvent) => void;
+export declare const ProFormList: import("react").NamedExoticComponent<ProFormListProps<FieldValues>>;
+export default ProFormList;