@1money/react-ui 1.16.0 → 1.17.0

package/es/components/Form/helper.js

@@ -0,0 +1,284 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+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());
+  });
+};
+import { 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';
+/**
+ * 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 var toPercent = function toPercent(col) {
+  if (col == null) return undefined;
+  return "".concat(Math.max(GRID_MIN, Math.min(GRID_COLUMNS, col)) / GRID_COLUMNS * 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.
+ */
+export var isFieldError = function isFieldError(value) {
+  if (!value || _typeof(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 = 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 && _typeof(item) === 'object') {
+          var child = _getFirstErrorPath(item);
+          if (child) return "".concat(key, ".").concat(i, ".").concat(child);
+        }
+      }
+    } else if (_typeof(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`.
+ */
+export { _getFirstErrorPath as getFirstErrorPath };
+export var 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']`.
+ */
+export var scrollToField = function scrollToField(name, options) {
+  var _a, _b, _c;
+  if (typeof document === 'undefined') return;
+  var config = _typeof(options) === 'object' ? options : {};
+  var attrName = escapeAttr(name);
+  var selectorByName = "[".concat(SELECTOR_NAME_ATTR, "=\"").concat(attrName, "\"]");
+  var selectorByData = "[".concat(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 : 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 : DEFAULT_SCROLL_BLOCK,
+    inline: (_c = config.inline) !== null && _c !== void 0 ? _c : 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.
+ */
+export var resolveStatus = function resolveStatus(explicit, fieldState) {
+  if (explicit) return explicit;
+  if (fieldState === null || fieldState === void 0 ? void 0 : fieldState.isValidating) return STATUS_VALIDATING;
+  if (fieldState === null || fieldState === void 0 ? void 0 : fieldState.error) return 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.
+ */
+export var 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.
+ */
+export var getStatusProps = function getStatusProps(status) {
+  return status === STATUS_ERROR ? {
+    invalid: true
+  } : status === 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.
+ */
+export var 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).
+ */
+export var 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.
+ */
+export var 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__*/_regeneratorRuntime.mark(function _callee2() {
+      var results, hit, _i2, _validators, fn, result;
+      return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            if (!(mode === 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__*/_regeneratorRuntime.mark(function _callee() {
+                return _regeneratorRuntime.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/Form/helper.js","components/src/components/Form/helper.ts"],"names":["__awaiter","thisArg","_arguments","P","generator","adopt","value","resolve","Promise","reject","fulfilled","step","next","e","rejected","result","done","then","apply","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","toPercent","col","undefined","concat","Math","max","min","isFieldError","_typeof","getFirstErrorPath","errors","_i","_Object$keys","Object","keys","length","key","Array","isArray","i","item","child","_getFirstErrorPath","escapeAttr","CSS","escape","replace","scrollToField","name","options","_a","_b","_c","document","config","attrName","selectorByName","selectorByData","el","querySelector","behavior","offset","rect","getBoundingClientRect","window","scrollTo","top","scrollY","scrollIntoView","block","inline","resolveStatus","explicit","fieldState","isValidating","error","normalizeValidateTrigger","getStatusProps","status","invalid","success","shallowEqualArray","a","b","every","v","is","normalizeValidateResult","wrapValidate","validate","mode","validators","values","_regeneratorRuntime","mark","_callee2","results","hit","_i2","_validators","fn","wrap","_callee2$","_context2","prev","all","map","_callee","_callee$","_context","t0","t1","sent","abrupt","stop","find"],"mappings":"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","file":"components/Form/helper.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};\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};",null],"sourceRoot":"../../../../../../../../../src"}

package/es/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/es/components/Form/index.js

@@ -0,0 +1,21 @@
+/**
+ * @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';
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvc3JjL2NvbXBvbmVudHMvRm9ybS9pbmRleC50cyIsImNvbXBvbmVudHMvRm9ybS9pbmRleC5qcyJdLCJuYW1lcyI6WyJGb3JtIiwiZGVmYXVsdCIsIkZvcm1JdGVtIl0sIm1hcHBpbmdzIjoiQUFBQTtBQ0NBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FEQ0EsU0FBU0EsSUFBSSxFQUFFQyxPQUFPLFFBQVEsUUFBUTtBQUN0QyxTQUFTQyxRQUFRLFFBQVEsWUFBWTtBQUVyQyxjQUFjLGFBQWEiLCJmaWxlIjoiY29tcG9uZW50cy9Gb3JtL2luZGV4LmpzIiwic291cmNlc0NvbnRlbnQiOltudWxsLCIvKipcbiAqIEBtb2R1bGUgRm9ybVxuICpcbiAqIEZvcm0gY29tcG9uZW50cyBidWlsdCBvbiB0b3Agb2YgYHJlYWN0LWhvb2stZm9ybWAgd2l0aCBsYXlvdXQgbWFuYWdlbWVudCxcbiAqIHZhbGlkYXRpb24gdHJpZ2dlcnMsIHNjcm9sbC10by1lcnJvciwgYW5kIHZhbHVlLWNoYW5nZSBzdWJzY3JpcHRpb25zLlxuICpcbiAqIEBleGFtcGxlXG4gKiBgYGB0c3hcbiAqIGltcG9ydCB7IEZvcm0sIEZvcm1JdGVtIH0gZnJvbSAnQDFtb25leS9yZWFjdC11aSc7XG4gKlxuICogPEZvcm0gZGVmYXVsdFZhbHVlcz17eyBuYW1lOiAnJyB9fSBvbkZpbmlzaD17aGFuZGxlU3VibWl0fT5cbiAqICAgPEZvcm1JdGVtIG5hbWU9XCJuYW1lXCIgbGFiZWw9XCJOYW1lXCIgcnVsZXM9e3sgcmVxdWlyZWQ6IHRydWUgfX0+XG4gKiAgICAgPElucHV0IC8+XG4gKiAgIDwvRm9ybUl0ZW0+XG4gKiA8L0Zvcm0+XG4gKiBgYGBcbiAqL1xuZXhwb3J0IHsgRm9ybSwgZGVmYXVsdCB9IGZyb20gJy4vRm9ybSc7XG5leHBvcnQgeyBGb3JtSXRlbSB9IGZyb20gJy4vRm9ybUl0ZW0nO1xuZXhwb3J0ICogZnJvbSAnLi9pbnRlcmZhY2UnOyJdLCJzb3VyY2VSb290IjoiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjIn0=

package/es/components/Form/interface.d.ts

@@ -0,0 +1,238 @@
+import type { CSSProperties, ReactNode } from 'react';
+import type { Control, DefaultValues, FieldErrors, FieldPath, FieldPathValue, FieldValues, RegisterOptions, UseFormProps, UseFormReturn, ControllerRenderProps, ControllerFieldState } from 'react-hook-form';
+import type { TRIGGER_BLUR, TRIGGER_CHANGE } from './constants';
+/**
+ * Subset of `RegisterOptions` used by `FormItem` for declarative validation rules.
+ *
+ * @template TFieldValues - The shape of the form values.
+ */
+export type FormItemRules<TFieldValues extends FieldValues = FieldValues> = Pick<RegisterOptions<TFieldValues>, 'required' | 'min' | 'max' | 'minLength' | 'maxLength' | 'pattern' | 'validate' | 'deps'>;
+/** Form layout direction. */
+export type FormLayout = 'horizontal' | 'vertical' | 'inline';
+/** Label text alignment within the label column. */
+export type FormLabelAlign = 'left' | 'right';
+/** Form size variant applied to all child items. */
+export type FormSize = 'small' | 'middle' | 'large';
+/** Validation status used for visual feedback on a form field. */
+export type FormValidateStatus = 'success' | 'warning' | 'error' | 'validating';
+/**
+ * Shared context value provided by `<Form>` to all descendant `<FormItem>` components.
+ */
+export interface FormContextValue {
+    /** Layout direction for the form. */
+    layout: FormLayout;
+    /** Alignment of labels within the label column. */
+    labelAlign: FormLabelAlign;
+    /** Label column span in a 12-column grid (0–12). */
+    labelCol: number;
+    /** Wrapper/control column span in a 12-column grid (0–12). */
+    wrapperCol: number;
+    /** Size variant applied to all form items. */
+    size: FormSize;
+    /** When `true`, all form fields are disabled. */
+    disabled?: boolean;
+    /** Whether to render a colon after each label. */
+    colon: boolean;
+    /** Whether to show the required asterisk mark on required fields. */
+    requiredMark: boolean;
+    /** The `react-hook-form` methods instance shared across the form. */
+    methods: UseFormReturn<FieldValues>;
+}
+/**
+ * Props for the `<Form>` component.
+ *
+ * Extends `react-hook-form`'s `UseFormProps` (excluding `defaultValues`) with
+ * layout configuration, submit callbacks, value-change subscriptions, and
+ * scroll-to-error behavior.
+ *
+ * @template TFieldValues - The shape of the form values.
+ */
+export interface FormProps<TFieldValues extends FieldValues = FieldValues> extends Omit<UseFormProps<TFieldValues>, 'defaultValues'> {
+    /** Initial values for the form fields. */
+    defaultValues?: DefaultValues<TFieldValues>;
+    /** An external `useForm()` return value to make the form fully controlled. */
+    form?: UseFormReturn<TFieldValues>;
+    /** Callback invoked with valid form values on successful submission. */
+    onFinish?: (values: TFieldValues) => void | Promise<void>;
+    /** Callback invoked with validation errors on failed submission. */
+    onFinishFailed?: (errors: FieldErrors<TFieldValues>) => void;
+    /** Callback fired when any watched field value changes. */
+    onValuesChange?: (values: TFieldValues, info: {
+        name?: FieldPath<TFieldValues>;
+        type?: string;
+    }) => void;
+    /** Field paths to subscribe to for `onValuesChange`. If omitted, all fields are watched. */
+    watchNames?: Array<FieldPath<TFieldValues>>;
+    /**
+     * Whether to scroll to the first invalid field on submit failure.
+     * Pass `true` for default scroll behavior, or an object to customize scroll options.
+     */
+    scrollToFirstError?: boolean | {
+        behavior?: ScrollBehavior;
+        block?: ScrollLogicalPosition;
+        inline?: ScrollLogicalPosition;
+        /** Pixel offset from the top when scrolling. */
+        offset?: number;
+    };
+    /** Layout direction. @defaultValue `'horizontal'` */
+    layout?: FormLayout;
+    /** Label text alignment. @defaultValue `'right'` */
+    labelAlign?: FormLabelAlign;
+    /** Label column span in a 12-column grid (0–12). @defaultValue `3` */
+    labelCol?: number;
+    /** Wrapper/control column span in a 12-column grid (0–12). @defaultValue `9` */
+    wrapperCol?: number;
+    /** Size variant. @defaultValue `'middle'` */
+    size?: FormSize;
+    /** When `true`, disables all form fields. */
+    disabled?: boolean;
+    /** Whether to show a colon after each label. @defaultValue `true` */
+    colon?: boolean;
+    /** Whether to show the required asterisk mark. @defaultValue `true` */
+    requiredMark?: boolean;
+    /** Additional CSS class name for the `<form>` element. */
+    className?: string;
+    /** Inline styles for the `<form>` element. */
+    style?: CSSProperties;
+    /** Form content (typically `<FormItem>` components). */
+    children?: ReactNode;
+}
+/**
+ * Props passed to a `FormItem` render-prop child function.
+ *
+ * @template TFieldValues - The shape of the form values.
+ */
+export interface FormItemRenderProps<TFieldValues extends FieldValues = FieldValues> {
+    /** Controller field bindings with additional status flags. Only present when `name` is set. */
+    field?: ControllerRenderProps<TFieldValues, FieldPath<TFieldValues>> & {
+        /** `true` when the field has a validation error. */
+        invalid?: boolean;
+        /** `true` when the field has been successfully validated. */
+        success?: boolean;
+    };
+    /** Controller field state (error, dirty, touched, etc.). Only present when `name` is set. */
+    fieldState?: ControllerFieldState;
+    /** The `react-hook-form` methods instance for imperative access. */
+    form: UseFormReturn<TFieldValues>;
+    /** Current snapshot of all form values. */
+    values: TFieldValues;
+}
+/**
+ * Extended `CSSProperties` including custom CSS variables for label/wrapper widths.
+ */
+export type FormItemStyle = CSSProperties & {
+    ['--om-form-label-width']?: string;
+    ['--om-form-wrapper-width']?: string;
+};
+/**
+ * Render-prop function signature used by `FormItem` children.
+ *
+ * @template TFieldValues - The shape of the form values.
+ */
+export type FormItemRenderFn<TFieldValues extends FieldValues> = (props: FormItemRenderProps<TFieldValues>) => ReactNode;
+/**
+ * Props for the `<FormItem>` component.
+ *
+ * Bridges `react-hook-form`'s `Controller` with layout, validation status,
+ * and trigger behavior.
+ *
+ * @template TFieldValues - The shape of the form values.
+ */
+export interface FormItemProps<TFieldValues extends FieldValues = FieldValues> {
+    /** Field path within the form values. When omitted, the item renders as a free (uncontrolled) wrapper. */
+    name?: FieldPath<TFieldValues>;
+    /** Label content rendered beside the field. */
+    label?: ReactNode;
+    /** Marks the field as required. When `rules.required` is set, this is inferred automatically. */
+    required?: boolean;
+    /** Declarative validation rules forwarded to `react-hook-form`'s `Controller`. */
+    rules?: FormItemRules<TFieldValues>;
+    /** Default value for the field. */
+    defaultValue?: FieldPathValue<TFieldValues, FieldPath<TFieldValues>>;
+    /** Custom help text displayed below the field. Overrides error messages when set. */
+    help?: ReactNode;
+    /** Extra content rendered below the help text. */
+    extra?: ReactNode;
+    /** Explicit validation status override. When set, bypasses automatic status derived from `fieldState`. */
+    validateStatus?: FormValidateStatus;
+    /** Field paths that trigger re-validation of this field when they change. */
+    dependencies?: Array<FieldPath<TFieldValues>>;
+    /** Additional field paths to watch, causing re-render when their values change. */
+    watchNames?: Array<FieldPath<TFieldValues>>;
+    /**
+     * Controls re-rendering behavior.
+     * - `true`: re-renders on every form value change.
+     * - A comparator function: re-renders when it returns `true`.
+     */
+    shouldUpdate?: boolean | ((prev: TFieldValues, next: TFieldValues) => boolean);
+    /** Event(s) that trigger validation. @defaultValue `[]` (validation on submit only) */
+    validateTrigger?: 'onChange' | 'onBlur' | Array<'onChange' | 'onBlur'>;
+    /**
+     * Controls multi-validator execution order.
+     * - `true`: runs validators sequentially, stops at first error.
+     * - `'parallel'`: runs all validators concurrently, returns first error found.
+     */
+    validateFirst?: boolean | 'parallel';
+    /** Debounce delay in milliseconds for triggered validation. */
+    validateDebounce?: number;
+    /** When `true`, renders only the field content without label/wrapper markup. */
+    noStyle?: boolean;
+    /** The prop name used to bind the controlled value to the child. @defaultValue `'value'` */
+    valuePropName?: string;
+    /** Additional CSS class name for the form item wrapper. */
+    className?: string;
+    /** Label column span override (0–12 grid). */
+    labelCol?: number;
+    /** Wrapper column span override (0–12 grid). */
+    wrapperCol?: number;
+    /** Field content — either a React node (auto-bound via `cloneElement`) or a render-prop function. */
+    children?: ReactNode | ((props: FormItemRenderProps<TFieldValues>) => ReactNode);
+}
+/**
+ * Internal props for the `<FormItemContent>` component.
+ *
+ * This is not part of the public API; it carries resolved context and
+ * validation state from `FormItem` down to the render layer.
+ *
+ * @template TFieldValues - The shape of the form values.
+ */
+export interface FormItemContentProps<TFieldValues extends FieldValues = FieldValues> {
+    /** Field path (determines controlled vs free branch). */
+    name?: FieldPath<TFieldValues>;
+    /** The `react-hook-form` `Control` instance. */
+    control: Control<TFieldValues>;
+    /** The `react-hook-form` methods instance. */
+    methods: UseFormReturn<TFieldValues>;
+    /** Merged validation rules. */
+    rules?: FormItemRules<TFieldValues>;
+    /** Default value for the Controller. */
+    defaultValue?: FormItemProps<TFieldValues>['defaultValue'];
+    /** Explicit validation status override. */
+    validateStatus?: FormValidateStatus;
+    /** Prop name used to bind the controlled value. */
+    valuePropName: string;
+    /** Help text displayed below the field. */
+    help?: ReactNode;
+    /** Extra content rendered below help text. */
+    extra?: ReactNode;
+    /** Form context value from the parent `<Form>`. */
+    ctx: FormContextValue | null;
+    /** Raw children from `FormItem`. */
+    children: FormItemProps<TFieldValues>['children'];
+    /** Resolved render-prop function, or `null` if children is a React node. */
+    renderFn: FormItemRenderFn<TFieldValues> | null;
+    /** Current snapshot of all form values. */
+    allValues: TFieldValues;
+    /** The `shouldUpdate` prop from `FormItem`. */
+    shouldUpdate?: FormItemProps<TFieldValues>['shouldUpdate'];
+    /** Whether the item should render based on `shouldUpdate` evaluation. */
+    shouldRender: boolean;
+    /**
+     * Wraps an event handler to conditionally trigger validation based on trigger mode.
+     *
+     * @param mode - The trigger mode (`'onChange'` or `'onBlur'`).
+     * @param fn - The original event handler to compose with.
+     * @returns A composed handler that calls `fn` and optionally triggers validation.
+     */
+    withTrigger: (mode: typeof TRIGGER_CHANGE | typeof TRIGGER_BLUR, fn?: (...args: unknown[]) => void) => (...args: unknown[]) => void;
+}

package/es/components/Form/interface.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcG9uZW50cy9Gb3JtL2ludGVyZmFjZS5qcyIsIm5hbWVzIjpbXSwic291cmNlUm9vdCI6Ii4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYyIsInNvdXJjZXMiOlsiY29tcG9uZW50cy9Gb3JtL2ludGVyZmFjZS5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQge307Il0sIm1hcHBpbmdzIjoiQUFBQSIsImlnbm9yZUxpc3QiOltdfQ==

package/es/components/Form/style/Form.css

@@ -0,0 +1 @@
+.om-react-ui-form,.om-react-ui-form-root{--om-form-spacing-xs:4px;--om-form-spacing-sm:8px;--om-form-spacing-md:12px;--om-form-spacing-lg:16px;--om-form-control-height:44px;--om-form-font-size-base:14px;--om-form-line-height-base:20px;--om-form-font-size-help:12px;--om-form-line-height-help:18px;--om-form-opacity-disabled:0.6}.om-react-ui-form-root{width:100%}.om-react-ui-form-layout-horizontal .om-react-ui-form-item-root{display:flex;align-items:flex-start}.om-react-ui-form-layout-vertical .om-react-ui-form-item-root{display:flex;flex-direction:column}.om-react-ui-form-layout-inline{display:flex;flex-wrap:wrap;gap:var(--om-form-spacing-lg)}.om-react-ui-form-label-left .om-react-ui-form-item-label{text-align:left}.om-react-ui-form-item,.om-react-ui-form-item-root{--om-form-spacing-xs:4px;--om-form-spacing-sm:8px;--om-form-spacing-md:12px;--om-form-spacing-lg:16px;--om-form-control-height:44px;--om-form-font-size-base:14px;--om-form-line-height-base:20px;--om-form-font-size-help:12px;--om-form-line-height-help:18px;--om-form-opacity-disabled:0.6}.om-react-ui-form-item-root{width:100%;margin-bottom:var(--om-form-spacing-lg)}.om-react-ui-form-item-label{display:flex;flex:0 0 var(--om-form-label-width,25%);align-items:center;justify-content:flex-end;min-width:-moz-fit-content;min-width:fit-content;min-height:var(--om-form-control-height);padding-right:var(--om-form-spacing-md);color:#131313;font-size:var(--om-form-font-size-base);line-height:var(--om-form-line-height-base);white-space:nowrap;text-align:right}.om-react-ui-form-item-label-required:before{margin-right:var(--om-form-spacing-xs);color:#ae0000;content:"*"}.om-react-ui-form-item-colon{margin-left:var(--om-form-spacing-xs)}.om-react-ui-form-item-control{flex:1 1 auto;max-width:var(--om-form-wrapper-width,75%)}.om-react-ui-form-item-content{display:flex;flex-direction:column;gap:var(--om-form-spacing-sm)}.om-react-ui-form-item-content-disabled{opacity:var(--om-form-opacity-disabled)}.om-react-ui-form-item-help{color:#646465;font-size:var(--om-form-font-size-help);line-height:var(--om-form-line-height-help)}.om-react-ui-form-item-help-error{color:#ae0000}.om-react-ui-form-item-help-warning{color:#db8600}.om-react-ui-form-item-help-success{color:#1f5800}.om-react-ui-form-item-content-error{--om-form-item-status-color:#ae0000}.om-react-ui-form-item-content-warning{--om-form-item-status-color:#db8600}.om-react-ui-form-item-content-success{--om-form-item-status-color:#1f5800}.om-react-ui-form-item-content-validating{--om-form-item-status-color:#3d7cf5}.om-react-ui-form-item-extra{color:#9fa3a3;font-size:var(--om-form-font-size-help);line-height:var(--om-form-line-height-help)}.om-react-ui-form-layout-vertical .om-react-ui-form-item-label{flex:0 0 auto;justify-content:flex-start;min-width:0;min-height:auto;margin-bottom:var(--om-form-spacing-sm);padding-right:0;white-space:normal;text-align:left}.om-react-ui-form-layout-vertical .om-react-ui-form-item-control{max-width:100%}.om-react-ui-form-layout-inline .om-react-ui-form-item-root{width:auto;margin-bottom:0}