@1money/react-ui 1.15.3 → 1.17.0

package/lib/components/Form/helper.d.ts

@@ -0,0 +1,120 @@
+import type { ControllerFieldState, FieldError, FieldErrors, FieldPath, FieldValues, RegisterOptions, ValidateResult } from 'react-hook-form';
+import type { FormItemProps, FormValidateStatus, FormProps } from './interface';
+/**
+ * Converts a 12-column grid span to a CSS percentage width string.
+ *
+ * @param col - Grid column count (0–12). Values are clamped to the valid range.
+ * @returns A CSS percentage string (e.g. `"25%"`), or `undefined` when `col` is `null`/`undefined`.
+ */
+export declare const toPercent: (col?: number) => string | undefined;
+/**
+ * Type guard that narrows an unknown value to a `FieldError`-like object.
+ *
+ * `isFieldError` assumes `react-hook-form` places `type` on leaf errors,
+ * and `getFirstErrorPath` relies on that to stop descending once a leaf is found.
+ * If RHF changes this contract, tighten this predicate (e.g. require `message`/`ref`
+ * or another stricter leaf-shape check) to avoid false positives on nested containers.
+ *
+ * Checks for the presence of `type`, `message`, or `ref` properties which
+ * are characteristic of `react-hook-form` field errors.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is a `FieldError`-like object.
+ */
+export declare const isFieldError: (value: unknown) => value is FieldError;
+/**
+ * Walks a nested `FieldErrors` tree (depth-first) and returns the dot-path
+ * of the first error encountered.
+ *
+ * Handles plain objects, arrays (e.g. field arrays), and deeply nested structures.
+ *
+ * @param errors - The `FieldErrors` object from `react-hook-form`.
+ * @returns The dot-separated path (e.g. `"items.0.name"`) or `null` if no error is found.
+ */
+export declare const getFirstErrorPath: (errors: FieldErrors) => string | null;
+/**
+ * Escapes a string for safe use inside a CSS attribute selector.
+ *
+ * Uses `CSS.escape` when available, with a regex fallback for SSR or
+ * environments without native support (e.g. nested field names like `"address.city"`).
+ *
+ * @param value - The raw attribute value to escape.
+ * @returns The escaped string safe for `querySelector`.
+ */
+export declare const escapeAttr: (value: string) => string;
+/**
+ * Scrolls the viewport to the first invalid field identified by `name`.
+ *
+ * Looks up the element using either the standard `name` attribute or the
+ * `data-form-item-name` data attribute. Supports custom scroll behavior
+ * via the `options` parameter.
+ *
+ * @param name - The field name (path) to scroll to.
+ * @param options - Scroll configuration from `FormProps['scrollToFirstError']`.
+ */
+export declare const scrollToField: (name: string, options?: FormProps["scrollToFirstError"]) => void;
+/**
+ * Resolves the effective validation status for a form field.
+ *
+ * An explicit `validateStatus` prop takes priority. Otherwise the status is
+ * derived from the `fieldState` provided by `react-hook-form`'s Controller.
+ *
+ * @param explicit - An explicit status override from props.
+ * @param fieldState - The Controller field state containing `error` and `isValidating`.
+ * @returns The resolved `FormValidateStatus`, or `undefined` if no status applies.
+ */
+export declare const resolveStatus: (explicit?: FormValidateStatus, fieldState?: Pick<ControllerFieldState, "error" | "isValidating">) => FormValidateStatus | undefined;
+/**
+ * Normalizes a `validateTrigger` prop into a consistent array form.
+ *
+ * @param value - A single trigger string, an array, or `undefined`.
+ * @returns An array of trigger modes (e.g. `['onChange', 'onBlur']`), or an empty array.
+ */
+export declare const normalizeValidateTrigger: (value?: FormItemProps<FieldValues>["validateTrigger"]) => ("onBlur" | "onChange")[];
+/**
+ * Maps a `FormValidateStatus` to boolean props suitable for Input-like components.
+ *
+ * @param status - The current validation status.
+ * @returns An object with `invalid: true`, `success: true`, or an empty object.
+ */
+export declare const getStatusProps: (status?: FormValidateStatus) => {
+    invalid: boolean;
+    success?: undefined;
+} | {
+    success: boolean;
+    invalid?: undefined;
+} | {
+    invalid?: undefined;
+    success?: undefined;
+};
+/**
+ * Performs a shallow comparison of two arrays using `Object.is` for each element.
+ *
+ * @param a - First array.
+ * @param b - Second array.
+ * @returns `true` if both arrays have the same length and identical elements by reference.
+ */
+export declare const shallowEqualArray: (a: unknown[], b: unknown[]) => boolean;
+/**
+ * Normalizes a custom `ValidateResult` to be compatible with `react-hook-form`.
+ *
+ * RHF treats `null` as a truthy error value, so this converts `null` to `true` (valid).
+ *
+ * @param result - The raw validation result.
+ * @returns The normalized result (`true` for valid, or an error string/boolean).
+ */
+export declare const normalizeValidateResult: (result: ValidateResult) => ValidateResult;
+/**
+ * Wraps a multi-validator record to honor `validateFirst` sequencing.
+ *
+ * When `mode` is `true`, validators run **sequentially** and stop at the first error.
+ * When `mode` is `'parallel'`, all validators run concurrently and the first error found is returned.
+ * When `mode` is falsy or `validate` is a single function, the original value is returned unchanged.
+ *
+ * @template TValues - The shape of the form values.
+ * @template TName - The field path type.
+ * @param validate - The validator or record of validators from `RegisterOptions`.
+ * @param mode - The `validateFirst` mode.
+ * @returns A wrapped validator function, or the original value when no wrapping is needed.
+ */
+export declare const wrapValidate: <TValues extends FieldValues, TName extends FieldPath<TValues>>(validate: NonNullable<RegisterOptions<TValues, TName>["validate"]>, mode?: FormItemProps<TValues>["validateFirst"]) => NonNullable<RegisterOptions<TValues, TName>["validate"]>;

package/lib/components/Form/helper.js

@@ -0,0 +1,290 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.wrapValidate = exports.toPercent = exports.shallowEqualArray = exports.scrollToField = exports.resolveStatus = exports.normalizeValidateTrigger = exports.normalizeValidateResult = exports.isFieldError = exports.getStatusProps = exports.getFirstErrorPath = exports.escapeAttr = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _constants = require("./constants");
+var __awaiter = void 0 && (void 0).__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());
+  });
+};
+/**
+ * Converts a 12-column grid span to a CSS percentage width string.
+ *
+ * @param col - Grid column count (0–12). Values are clamped to the valid range.
+ * @returns A CSS percentage string (e.g. `"25%"`), or `undefined` when `col` is `null`/`undefined`.
+ */
+var toPercent = exports.toPercent = function toPercent(col) {
+  if (col == null) return undefined;
+  return "".concat(Math.max(_constants.GRID_MIN, Math.min(_constants.GRID_COLUMNS, col)) / _constants.GRID_COLUMNS * _constants.PERCENT, "%");
+};
+/**
+ * Type guard that narrows an unknown value to a `FieldError`-like object.
+ *
+ * `isFieldError` assumes `react-hook-form` places `type` on leaf errors,
+ * and `getFirstErrorPath` relies on that to stop descending once a leaf is found.
+ * If RHF changes this contract, tighten this predicate (e.g. require `message`/`ref`
+ * or another stricter leaf-shape check) to avoid false positives on nested containers.
+ *
+ * Checks for the presence of `type`, `message`, or `ref` properties which
+ * are characteristic of `react-hook-form` field errors.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is a `FieldError`-like object.
+ */
+var isFieldError = exports.isFieldError = function isFieldError(value) {
+  if (!value || (0, _typeof2["default"])(value) !== 'object') return false;
+  return 'type' in value || 'message' in value || 'ref' in value;
+};
+/**
+ * Walks a nested `FieldErrors` tree (depth-first) and returns the dot-path
+ * of the first error encountered.
+ *
+ * Handles plain objects, arrays (e.g. field arrays), and deeply nested structures.
+ *
+ * @param errors - The `FieldErrors` object from `react-hook-form`.
+ * @returns The dot-separated path (e.g. `"items.0.name"`) or `null` if no error is found.
+ */
+var _getFirstErrorPath = exports.getFirstErrorPath = function getFirstErrorPath(errors) {
+  for (var _i = 0, _Object$keys = Object.keys(errors); _i < _Object$keys.length; _i++) {
+    var key = _Object$keys[_i];
+    var value = errors[key];
+    if (!value) continue;
+    if (isFieldError(value)) return key;
+    if (Array.isArray(value)) {
+      for (var i = 0; i < value.length; i += 1) {
+        var item = value[i];
+        if (!item) continue;
+        if (isFieldError(item)) return "".concat(key, ".").concat(i);
+        if (item && (0, _typeof2["default"])(item) === 'object') {
+          var child = _getFirstErrorPath(item);
+          if (child) return "".concat(key, ".").concat(i, ".").concat(child);
+        }
+      }
+    } else if ((0, _typeof2["default"])(value) === 'object') {
+      var _child = _getFirstErrorPath(value);
+      if (_child) return "".concat(key, ".").concat(_child);
+    }
+  }
+  return null;
+};
+/**
+ * Escapes a string for safe use inside a CSS attribute selector.
+ *
+ * Uses `CSS.escape` when available, with a regex fallback for SSR or
+ * environments without native support (e.g. nested field names like `"address.city"`).
+ *
+ * @param value - The raw attribute value to escape.
+ * @returns The escaped string safe for `querySelector`.
+ */
+var escapeAttr = exports.escapeAttr = function escapeAttr(value) {
+  return typeof CSS !== 'undefined' && CSS.escape ? CSS.escape(value) : value.replace(/([^\w-])/g, '\\$1');
+};
+/**
+ * Scrolls the viewport to the first invalid field identified by `name`.
+ *
+ * Looks up the element using either the standard `name` attribute or the
+ * `data-form-item-name` data attribute. Supports custom scroll behavior
+ * via the `options` parameter.
+ *
+ * @param name - The field name (path) to scroll to.
+ * @param options - Scroll configuration from `FormProps['scrollToFirstError']`.
+ */
+var scrollToField = exports.scrollToField = function scrollToField(name, options) {
+  var _a, _b, _c;
+  if (typeof document === 'undefined') return;
+  var config = (0, _typeof2["default"])(options) === 'object' ? options : {};
+  var attrName = escapeAttr(name);
+  var selectorByName = "[".concat(_constants.SELECTOR_NAME_ATTR, "=\"").concat(attrName, "\"]");
+  var selectorByData = "[".concat(_constants.SELECTOR_DATA_FORM_ITEM_ATTR, "=\"").concat(attrName, "\"]");
+  var el = document.querySelector(selectorByName) || document.querySelector(selectorByData);
+  if (!el) return;
+  var behavior = (_a = config.behavior) !== null && _a !== void 0 ? _a : _constants.DEFAULT_SCROLL_BEHAVIOR;
+  if (typeof config.offset === 'number') {
+    var rect = el.getBoundingClientRect();
+    window.scrollTo({
+      top: rect.top + window.scrollY - config.offset,
+      behavior: behavior
+    });
+    return;
+  }
+  el.scrollIntoView({
+    behavior: behavior,
+    block: (_b = config.block) !== null && _b !== void 0 ? _b : _constants.DEFAULT_SCROLL_BLOCK,
+    inline: (_c = config.inline) !== null && _c !== void 0 ? _c : _constants.DEFAULT_SCROLL_INLINE
+  });
+};
+/**
+ * Resolves the effective validation status for a form field.
+ *
+ * An explicit `validateStatus` prop takes priority. Otherwise the status is
+ * derived from the `fieldState` provided by `react-hook-form`'s Controller.
+ *
+ * @param explicit - An explicit status override from props.
+ * @param fieldState - The Controller field state containing `error` and `isValidating`.
+ * @returns The resolved `FormValidateStatus`, or `undefined` if no status applies.
+ */
+var resolveStatus = exports.resolveStatus = function resolveStatus(explicit, fieldState) {
+  if (explicit) return explicit;
+  if (fieldState === null || fieldState === void 0 ? void 0 : fieldState.isValidating) return _constants.STATUS_VALIDATING;
+  if (fieldState === null || fieldState === void 0 ? void 0 : fieldState.error) return _constants.STATUS_ERROR;
+  return undefined;
+};
+/**
+ * Normalizes a `validateTrigger` prop into a consistent array form.
+ *
+ * @param value - A single trigger string, an array, or `undefined`.
+ * @returns An array of trigger modes (e.g. `['onChange', 'onBlur']`), or an empty array.
+ */
+var normalizeValidateTrigger = exports.normalizeValidateTrigger = function normalizeValidateTrigger(value) {
+  if (!value) return [];
+  return Array.isArray(value) ? value : [value];
+};
+/**
+ * Maps a `FormValidateStatus` to boolean props suitable for Input-like components.
+ *
+ * @param status - The current validation status.
+ * @returns An object with `invalid: true`, `success: true`, or an empty object.
+ */
+var getStatusProps = exports.getStatusProps = function getStatusProps(status) {
+  return status === _constants.STATUS_ERROR ? {
+    invalid: true
+  } : status === _constants.STATUS_SUCCESS ? {
+    success: true
+  } : {};
+};
+/**
+ * Performs a shallow comparison of two arrays using `Object.is` for each element.
+ *
+ * @param a - First array.
+ * @param b - Second array.
+ * @returns `true` if both arrays have the same length and identical elements by reference.
+ */
+var shallowEqualArray = exports.shallowEqualArray = function shallowEqualArray(a, b) {
+  return a.length === b.length && a.every(function (v, i) {
+    return Object.is(v, b[i]);
+  });
+};
+/**
+ * Normalizes a custom `ValidateResult` to be compatible with `react-hook-form`.
+ *
+ * RHF treats `null` as a truthy error value, so this converts `null` to `true` (valid).
+ *
+ * @param result - The raw validation result.
+ * @returns The normalized result (`true` for valid, or an error string/boolean).
+ */
+var normalizeValidateResult = exports.normalizeValidateResult = function normalizeValidateResult(result) {
+  return result === null ? true : result;
+};
+/**
+ * Wraps a multi-validator record to honor `validateFirst` sequencing.
+ *
+ * When `mode` is `true`, validators run **sequentially** and stop at the first error.
+ * When `mode` is `'parallel'`, all validators run concurrently and the first error found is returned.
+ * When `mode` is falsy or `validate` is a single function, the original value is returned unchanged.
+ *
+ * @template TValues - The shape of the form values.
+ * @template TName - The field path type.
+ * @param validate - The validator or record of validators from `RegisterOptions`.
+ * @param mode - The `validateFirst` mode.
+ * @returns A wrapped validator function, or the original value when no wrapping is needed.
+ */
+var wrapValidate = exports.wrapValidate = function wrapValidate(validate, mode) {
+  if (!validate || !mode || typeof validate === 'function') return validate;
+  var validators = Object.values(validate);
+  return function (value, values) {
+    return __awaiter(void 0, void 0, void 0, /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+      var results, hit, _i2, _validators, fn, result;
+      return _regenerator["default"].wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            if (!(mode === _constants.VALIDATE_PARALLEL)) {
+              _context2.next = 6;
+              break;
+            }
+            _context2.next = 3;
+            return Promise.all(validators.map(function (fn) {
+              return __awaiter(void 0, void 0, void 0, /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+                return _regenerator["default"].wrap(function _callee$(_context) {
+                  while (1) switch (_context.prev = _context.next) {
+                    case 0:
+                      _context.t0 = normalizeValidateResult;
+                      _context.next = 3;
+                      return Promise.resolve(fn(value, values));
+                    case 3:
+                      _context.t1 = _context.sent;
+                      return _context.abrupt("return", (0, _context.t0)(_context.t1));
+                    case 5:
+                    case "end":
+                      return _context.stop();
+                  }
+                }, _callee);
+              }));
+            }));
+          case 3:
+            results = _context2.sent;
+            hit = results.find(function (result) {
+              return result !== true && result !== undefined;
+            });
+            return _context2.abrupt("return", hit !== null && hit !== void 0 ? hit : true);
+          case 6:
+            _i2 = 0, _validators = validators;
+          case 7:
+            if (!(_i2 < _validators.length)) {
+              _context2.next = 19;
+              break;
+            }
+            fn = _validators[_i2];
+            _context2.t0 = normalizeValidateResult;
+            _context2.next = 12;
+            return fn(value, values);
+          case 12:
+            _context2.t1 = _context2.sent;
+            result = (0, _context2.t0)(_context2.t1);
+            if (!(result !== true && result !== undefined)) {
+              _context2.next = 16;
+              break;
+            }
+            return _context2.abrupt("return", result);
+          case 16:
+            _i2++;
+            _context2.next = 7;
+            break;
+          case 19:
+            return _context2.abrupt("return", true);
+          case 20:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    }));
+  };
+};
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/src/components/Form/helper.ts","components/Form/helper.js"],"names":["_constants","require","__awaiter","thisArg","_arguments","P","generator","adopt","value","resolve","Promise","reject","fulfilled","step","next","e","rejected","result","done","then","apply","toPercent","exports","col","undefined","concat","Math","max","GRID_MIN","min","GRID_COLUMNS","PERCENT","isFieldError","_typeof2","getFirstErrorPath","errors","_i","_Object$keys","Object","keys","length","key","Array","isArray","i","item","child","escapeAttr","CSS","escape","replace","scrollToField","name","options","_a","_b","_c","document","config","attrName","selectorByName","SELECTOR_NAME_ATTR","selectorByData","SELECTOR_DATA_FORM_ITEM_ATTR","el","querySelector","behavior","DEFAULT_SCROLL_BEHAVIOR","offset","rect","getBoundingClientRect","window","scrollTo","top","scrollY","scrollIntoView","block","DEFAULT_SCROLL_BLOCK","inline","DEFAULT_SCROLL_INLINE","resolveStatus","explicit","fieldState","isValidating","STATUS_VALIDATING","error","STATUS_ERROR","normalizeValidateTrigger","getStatusProps","status","invalid","STATUS_SUCCESS","success","shallowEqualArray","a","b","every","v","is","normalizeValidateResult","wrapValidate","validate","mode","validators","values","_regenerator","mark","_callee2","results","hit","_i2","_validators","fn","wrap","_callee2$","_context2","prev","VALIDATE_PARALLEL","all","map","_callee","_callee$","_context","t0","t1","sent","abrupt","stop","find"],"mappings":"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","file":"components/Form/helper.js","sourcesContent":[null,"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};\nimport { DEFAULT_SCROLL_BEHAVIOR, DEFAULT_SCROLL_BLOCK, DEFAULT_SCROLL_INLINE, GRID_COLUMNS, GRID_MIN, PERCENT, SELECTOR_DATA_FORM_ITEM_ATTR, SELECTOR_NAME_ATTR, STATUS_ERROR, STATUS_SUCCESS, STATUS_VALIDATING, VALIDATE_PARALLEL } from './constants';\n/**\n * Converts a 12-column grid span to a CSS percentage width string.\n *\n * @param col - Grid column count (0–12). Values are clamped to the valid range.\n * @returns A CSS percentage string (e.g. `\"25%\"`), or `undefined` when `col` is `null`/`undefined`.\n */\nexport const toPercent = (col) => {\n    if (col == null)\n        return undefined;\n    return `${(Math.max(GRID_MIN, Math.min(GRID_COLUMNS, col)) / GRID_COLUMNS) * PERCENT}%`;\n};\n/**\n * Type guard that narrows an unknown value to a `FieldError`-like object.\n *\n * `isFieldError` assumes `react-hook-form` places `type` on leaf errors,\n * and `getFirstErrorPath` relies on that to stop descending once a leaf is found.\n * If RHF changes this contract, tighten this predicate (e.g. require `message`/`ref`\n * or another stricter leaf-shape check) to avoid false positives on nested containers.\n *\n * Checks for the presence of `type`, `message`, or `ref` properties which\n * are characteristic of `react-hook-form` field errors.\n *\n * @param value - The value to check.\n * @returns `true` if the value is a `FieldError`-like object.\n */\nexport const isFieldError = (value) => {\n    if (!value || typeof value !== 'object')\n        return false;\n    return 'type' in value || 'message' in value || 'ref' in value;\n};\n/**\n * Walks a nested `FieldErrors` tree (depth-first) and returns the dot-path\n * of the first error encountered.\n *\n * Handles plain objects, arrays (e.g. field arrays), and deeply nested structures.\n *\n * @param errors - The `FieldErrors` object from `react-hook-form`.\n * @returns The dot-separated path (e.g. `\"items.0.name\"`) or `null` if no error is found.\n */\nexport const getFirstErrorPath = (errors) => {\n    for (const key of Object.keys(errors)) {\n        const value = errors[key];\n        if (!value)\n            continue;\n        if (isFieldError(value))\n            return key;\n        if (Array.isArray(value)) {\n            for (let i = 0; i < value.length; i += 1) {\n                const item = value[i];\n                if (!item)\n                    continue;\n                if (isFieldError(item))\n                    return `${key}.${i}`;\n                if (item && typeof item === 'object') {\n                    const child = getFirstErrorPath(item);\n                    if (child)\n                        return `${key}.${i}.${child}`;\n                }\n            }\n        }\n        else if (typeof value === 'object') {\n            const child = getFirstErrorPath(value);\n            if (child)\n                return `${key}.${child}`;\n        }\n    }\n    return null;\n};\n/**\n * Escapes a string for safe use inside a CSS attribute selector.\n *\n * Uses `CSS.escape` when available, with a regex fallback for SSR or\n * environments without native support (e.g. nested field names like `\"address.city\"`).\n *\n * @param value - The raw attribute value to escape.\n * @returns The escaped string safe for `querySelector`.\n */\nexport const escapeAttr = (value) => typeof CSS !== 'undefined' && CSS.escape\n    ? CSS.escape(value)\n    : value.replace(/([^\\w-])/g, '\\\\$1');\n/**\n * Scrolls the viewport to the first invalid field identified by `name`.\n *\n * Looks up the element using either the standard `name` attribute or the\n * `data-form-item-name` data attribute. Supports custom scroll behavior\n * via the `options` parameter.\n *\n * @param name - The field name (path) to scroll to.\n * @param options - Scroll configuration from `FormProps['scrollToFirstError']`.\n */\nexport const scrollToField = (name, options) => {\n    var _a, _b, _c;\n    if (typeof document === 'undefined')\n        return;\n    const config = typeof options === 'object' ? options : {};\n    const attrName = escapeAttr(name);\n    const selectorByName = `[${SELECTOR_NAME_ATTR}=\"${attrName}\"]`;\n    const selectorByData = `[${SELECTOR_DATA_FORM_ITEM_ATTR}=\"${attrName}\"]`;\n    const el = (document.querySelector(selectorByName) || document.querySelector(selectorByData));\n    if (!el)\n        return;\n    const behavior = (_a = config.behavior) !== null && _a !== void 0 ? _a : DEFAULT_SCROLL_BEHAVIOR;\n    if (typeof config.offset === 'number') {\n        const rect = el.getBoundingClientRect();\n        window.scrollTo({\n            top: rect.top + window.scrollY - config.offset,\n            behavior,\n        });\n        return;\n    }\n    el.scrollIntoView({\n        behavior,\n        block: (_b = config.block) !== null && _b !== void 0 ? _b : DEFAULT_SCROLL_BLOCK,\n        inline: (_c = config.inline) !== null && _c !== void 0 ? _c : DEFAULT_SCROLL_INLINE,\n    });\n};\n/**\n * Resolves the effective validation status for a form field.\n *\n * An explicit `validateStatus` prop takes priority. Otherwise the status is\n * derived from the `fieldState` provided by `react-hook-form`'s Controller.\n *\n * @param explicit - An explicit status override from props.\n * @param fieldState - The Controller field state containing `error` and `isValidating`.\n * @returns The resolved `FormValidateStatus`, or `undefined` if no status applies.\n */\nexport const resolveStatus = (explicit, fieldState) => {\n    if (explicit)\n        return explicit;\n    if (fieldState === null || fieldState === void 0 ? void 0 : fieldState.isValidating)\n        return STATUS_VALIDATING;\n    if (fieldState === null || fieldState === void 0 ? void 0 : fieldState.error)\n        return STATUS_ERROR;\n    return undefined;\n};\n/**\n * Normalizes a `validateTrigger` prop into a consistent array form.\n *\n * @param value - A single trigger string, an array, or `undefined`.\n * @returns An array of trigger modes (e.g. `['onChange', 'onBlur']`), or an empty array.\n */\nexport const normalizeValidateTrigger = (value) => {\n    if (!value)\n        return [];\n    return Array.isArray(value) ? value : [value];\n};\n/**\n * Maps a `FormValidateStatus` to boolean props suitable for Input-like components.\n *\n * @param status - The current validation status.\n * @returns An object with `invalid: true`, `success: true`, or an empty object.\n */\nexport const getStatusProps = (status) => (status === STATUS_ERROR\n    ? { invalid: true }\n    : status === STATUS_SUCCESS\n        ? { success: true }\n        : {});\n/**\n * Performs a shallow comparison of two arrays using `Object.is` for each element.\n *\n * @param a - First array.\n * @param b - Second array.\n * @returns `true` if both arrays have the same length and identical elements by reference.\n */\nexport const shallowEqualArray = (a, b) => a.length === b.length && a.every((v, i) => Object.is(v, b[i]));\n/**\n * Normalizes a custom `ValidateResult` to be compatible with `react-hook-form`.\n *\n * RHF treats `null` as a truthy error value, so this converts `null` to `true` (valid).\n *\n * @param result - The raw validation result.\n * @returns The normalized result (`true` for valid, or an error string/boolean).\n */\nexport const normalizeValidateResult = (result) => (result === null ? true : result);\n/**\n * Wraps a multi-validator record to honor `validateFirst` sequencing.\n *\n * When `mode` is `true`, validators run **sequentially** and stop at the first error.\n * When `mode` is `'parallel'`, all validators run concurrently and the first error found is returned.\n * When `mode` is falsy or `validate` is a single function, the original value is returned unchanged.\n *\n * @template TValues - The shape of the form values.\n * @template TName - The field path type.\n * @param validate - The validator or record of validators from `RegisterOptions`.\n * @param mode - The `validateFirst` mode.\n * @returns A wrapped validator function, or the original value when no wrapping is needed.\n */\nexport const wrapValidate = (validate, mode) => {\n    if (!validate || !mode || typeof validate === 'function')\n        return validate;\n    const validators = Object.values(validate);\n    return (value, values) => __awaiter(void 0, void 0, void 0, function* () {\n        if (mode === VALIDATE_PARALLEL) {\n            const results = yield Promise.all(validators.map((fn) => __awaiter(void 0, void 0, void 0, function* () {\n                return normalizeValidateResult(yield Promise.resolve(fn(value, values)));\n            })));\n            const hit = results.find(result => result !== true && result !== undefined);\n            return hit !== null && hit !== void 0 ? hit : true;\n        }\n        for (const fn of validators) {\n            const result = normalizeValidateResult(yield fn(value, values));\n            if (result !== true && result !== undefined)\n                return result;\n        }\n        return true;\n    });\n};"],"sourceRoot":"../../../../../../../../../src"}

package/lib/components/Form/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @module Form
+ *
+ * Form components built on top of `react-hook-form` with layout management,
+ * validation triggers, scroll-to-error, and value-change subscriptions.
+ *
+ * @example
+ * ```tsx
+ * import { Form, FormItem } from '@1money/react-ui';
+ *
+ * <Form defaultValues={{ name: '' }} onFinish={handleSubmit}>
+ *   <FormItem name="name" label="Name" rules={{ required: true }}>
+ *     <Input />
+ *   </FormItem>
+ * </Form>
+ * ```
+ */
+export { Form, default } from './Form';
+export { FormItem } from './FormItem';
+export * from './interface';

package/lib/components/Form/index.js

@@ -0,0 +1,45 @@
+"use strict";
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  Form: true,
+  FormItem: true
+};
+Object.defineProperty(exports, "Form", {
+  enumerable: true,
+  get: function get() {
+    return _Form.Form;
+  }
+});
+Object.defineProperty(exports, "FormItem", {
+  enumerable: true,
+  get: function get() {
+    return _FormItem.FormItem;
+  }
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function get() {
+    return _Form["default"];
+  }
+});
+var _Form = _interopRequireWildcard(require("./Form"));
+var _FormItem = require("./FormItem");
+var _interface = require("./interface");
+Object.keys(_interface).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _interface[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _interface[key];
+    }
+  });
+});
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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