@1money/react-ui 1.16.0 → 1.17.1-alpha.0

package/lib/components/ProForm/layouts/useOverlayForm.d.ts

@@ -0,0 +1,53 @@
+import type { CSSProperties, ReactElement, ReactNode } from 'react';
+/** Configuration options for the {@link useOverlayForm} hook. */
+interface UseOverlayFormOptions<TValues> {
+    /** Controlled open state. */
+    open?: boolean;
+    /** Callback when the open state changes. */
+    onOpenChange?: (open: boolean) => void;
+    /** Element that opens the overlay when clicked. */
+    trigger?: ReactElement;
+    /** Delay (ms) before auto-closing after submit. */
+    submitTimeout?: number;
+    /** Whether to auto-close after a successful submit. @default true */
+    autoClose?: boolean;
+    /** Whether to unmount overlay content when closed. @default true */
+    destroyOnClose?: boolean;
+    /** Overlay width. */
+    width?: string | number;
+    /** Form finish handler. Return `false` to prevent auto-close. */
+    onFinish?: (values: TValues) => void | boolean | Promise<void | boolean>;
+    /** Inline styles from the overlay component. */
+    overlayStyle?: CSSProperties;
+    /** The overlay's own `onHide` callback. */
+    onOverlayHide?: (...args: unknown[]) => void;
+}
+/** Return shape of {@link useOverlayForm}. */
+export interface UseOverlayFormResult<TValues> {
+    /** Effective open state (controlled or uncontrolled). */
+    mergedOpen: boolean;
+    /** Whether overlay container should stay mounted. */
+    shouldRenderPanel: boolean;
+    /** Optional trigger element that opens the overlay. */
+    triggerNode: ReactNode;
+    /** Wrapped finish handler with optional auto-close behavior. */
+    handleFinish: (values: TValues) => Promise<void | boolean | undefined>;
+    /** Wrapped overlay hide handler. */
+    handleHide: (...args: unknown[]) => void;
+    /** Merged overlay style (base style + width override). */
+    mergedStyle: CSSProperties;
+    /** Imperative open-state setter honoring controlled mode. */
+    changeOpen: (nextOpen: boolean) => void;
+}
+/**
+ * Shared hook that powers both {@link ModalForm} and {@link DrawerForm}.
+ *
+ * Manages open/close state, trigger element cloning, auto-close with optional
+ * timeout after submit, and overlay visibility lifecycle.
+ *
+ * @typeParam TValues - The form values type.
+ * @param options - Configuration options.
+ * @returns An object with `mergedOpen`, `triggerNode`, `handleFinish`, `handleHide`, and more.
+ */
+export declare function useOverlayForm<TValues>({ open, onOpenChange, trigger, submitTimeout, autoClose, destroyOnClose, width, onFinish, overlayStyle, onOverlayHide, }: UseOverlayFormOptions<TValues>): UseOverlayFormResult<TValues>;
+export {};

package/lib/components/ProForm/layouts/useOverlayForm.js

@@ -0,0 +1,147 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useOverlayForm = useOverlayForm;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = require("react");
+var _useMemoizedFn = _interopRequireDefault(require("../../useMemoizedFn"));
+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());
+  });
+};
+/**
+ * Shared hook that powers both {@link ModalForm} and {@link DrawerForm}.
+ *
+ * Manages open/close state, trigger element cloning, auto-close with optional
+ * timeout after submit, and overlay visibility lifecycle.
+ *
+ * @typeParam TValues - The form values type.
+ * @param options - Configuration options.
+ * @returns An object with `mergedOpen`, `triggerNode`, `handleFinish`, `handleHide`, and more.
+ */
+function useOverlayForm(_ref) {
+  var _this = this;
+  var open = _ref.open,
+    onOpenChange = _ref.onOpenChange,
+    trigger = _ref.trigger,
+    submitTimeout = _ref.submitTimeout,
+    _ref$autoClose = _ref.autoClose,
+    autoClose = _ref$autoClose === void 0 ? true : _ref$autoClose,
+    _ref$destroyOnClose = _ref.destroyOnClose,
+    destroyOnClose = _ref$destroyOnClose === void 0 ? true : _ref$destroyOnClose,
+    width = _ref.width,
+    onFinish = _ref.onFinish,
+    overlayStyle = _ref.overlayStyle,
+    onOverlayHide = _ref.onOverlayHide;
+  var _useState = (0, _react.useState)(false),
+    _useState2 = (0, _slicedToArray2["default"])(_useState, 2),
+    innerOpen = _useState2[0],
+    setInnerOpen = _useState2[1];
+  var closeTimerRef = (0, _react.useRef)(null);
+  var mergedOpen = open !== null && open !== void 0 ? open : innerOpen;
+  var changeOpen = (0, _useMemoizedFn["default"])(function (nextOpen) {
+    if (open === undefined) {
+      setInnerOpen(nextOpen);
+    }
+    onOpenChange === null || onOpenChange === void 0 ? void 0 : onOpenChange(nextOpen);
+  });
+  var clearCloseTimer = (0, _useMemoizedFn["default"])(function () {
+    if (!closeTimerRef.current) return;
+    clearTimeout(closeTimerRef.current);
+    closeTimerRef.current = null;
+  });
+  var handleFinish = (0, _useMemoizedFn["default"])(function (values) {
+    return __awaiter(_this, void 0, void 0, /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+      var result;
+      return _regenerator["default"].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:
+            result = _context.sent;
+            if (autoClose && result !== false) {
+              clearCloseTimer();
+              if (typeof submitTimeout === 'number' && submitTimeout > 0) {
+                closeTimerRef.current = setTimeout(function () {
+                  changeOpen(false);
+                  closeTimerRef.current = null;
+                }, submitTimeout);
+              } else {
+                changeOpen(false);
+              }
+            }
+            return _context.abrupt("return", result);
+          case 5:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+  });
+  var triggerNode = (0, _react.useMemo)(function () {
+    if (!trigger || ! /*#__PURE__*/(0, _react.isValidElement)(trigger)) return null;
+    return /*#__PURE__*/(0, _react.cloneElement)(trigger, {
+      onClick: function onClick(event) {
+        var _a;
+        var triggerOnClick = (_a = trigger.props) === null || _a === void 0 ? void 0 : _a.onClick;
+        triggerOnClick === null || triggerOnClick === void 0 ? void 0 : triggerOnClick(event);
+        if (event.defaultPrevented) return;
+        changeOpen(true);
+      }
+    });
+  }, [changeOpen, trigger]);
+  var handleHide = (0, _useMemoizedFn["default"])(function () {
+    clearCloseTimer();
+    onOverlayHide === null || onOverlayHide === void 0 ? void 0 : onOverlayHide.apply(void 0, arguments);
+    changeOpen(false);
+  });
+  var shouldRenderPanel = mergedOpen || !destroyOnClose;
+  var mergedStyle = (0, _react.useMemo)(function () {
+    return Object.assign(Object.assign({}, overlayStyle || {}), width !== undefined ? {
+      width: width
+    } : {});
+  }, [overlayStyle, width]);
+  (0, _react.useEffect)(function () {
+    return function () {
+      clearCloseTimer();
+    };
+  }, [clearCloseTimer]);
+  return {
+    mergedOpen: mergedOpen,
+    shouldRenderPanel: shouldRenderPanel,
+    triggerNode: triggerNode,
+    handleFinish: handleFinish,
+    handleHide: handleHide,
+    mergedStyle: mergedStyle,
+    changeOpen: changeOpen
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/ProForm/src/components/ProForm/layouts/useOverlayForm.ts","components/ProForm/layouts/useOverlayForm.js"],"names":["_react","require","_useMemoizedFn","_interopRequireDefault","__awaiter","thisArg","_arguments","P","generator","adopt","value","resolve","Promise","reject","fulfilled","step","next","e","rejected","result","done","then","apply","useOverlayForm","_ref","_this","open","onOpenChange","trigger","submitTimeout","_ref$autoClose","autoClose","_ref$destroyOnClose","destroyOnClose","width","onFinish","overlayStyle","onOverlayHide","_useState","useState","_useState2","_slicedToArray2","innerOpen","setInnerOpen","closeTimerRef","useRef","mergedOpen","changeOpen","useMemoizedFn","nextOpen","undefined","clearCloseTimer","current","clearTimeout","handleFinish","values","_regenerator","mark","_callee","wrap","_callee$","_context","prev","sent","setTimeout","abrupt","stop","triggerNode","useMemo","isValidElement","cloneElement","onClick","event","_a","triggerOnClick","props","defaultPrevented","handleHide","arguments","shouldRenderPanel","mergedStyle","Object","assign","useEffect"],"mappings":"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","file":"components/ProForm/layouts/useOverlayForm.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 { cloneElement, isValidElement, useEffect, useMemo, useRef, useState } from 'react';\nimport useMemoizedFn from '../../useMemoizedFn';\n/**\n * Shared hook that powers both {@link ModalForm} and {@link DrawerForm}.\n *\n * Manages open/close state, trigger element cloning, auto-close with optional\n * timeout after submit, and overlay visibility lifecycle.\n *\n * @typeParam TValues - The form values type.\n * @param options - Configuration options.\n * @returns An object with `mergedOpen`, `triggerNode`, `handleFinish`, `handleHide`, and more.\n */\nexport function useOverlayForm({ open, onOpenChange, trigger, submitTimeout, autoClose = true, destroyOnClose = true, width, onFinish, overlayStyle, onOverlayHide, }) {\n    const [innerOpen, setInnerOpen] = useState(false);\n    const closeTimerRef = useRef(null);\n    const mergedOpen = open !== null && open !== void 0 ? open : innerOpen;\n    const changeOpen = useMemoizedFn((nextOpen) => {\n        if (open === undefined) {\n            setInnerOpen(nextOpen);\n        }\n        onOpenChange === null || onOpenChange === void 0 ? void 0 : onOpenChange(nextOpen);\n    });\n    const clearCloseTimer = useMemoizedFn(() => {\n        if (!closeTimerRef.current)\n            return;\n        clearTimeout(closeTimerRef.current);\n        closeTimerRef.current = null;\n    });\n    const handleFinish = useMemoizedFn((values) => __awaiter(this, void 0, void 0, function* () {\n        const result = yield (onFinish === null || onFinish === void 0 ? void 0 : onFinish(values));\n        if (autoClose && result !== false) {\n            clearCloseTimer();\n            if (typeof submitTimeout === 'number' && submitTimeout > 0) {\n                closeTimerRef.current = setTimeout(() => {\n                    changeOpen(false);\n                    closeTimerRef.current = null;\n                }, submitTimeout);\n            }\n            else {\n                changeOpen(false);\n            }\n        }\n        return result;\n    }));\n    const triggerNode = useMemo(() => {\n        if (!trigger || !isValidElement(trigger))\n            return null;\n        return cloneElement(trigger, {\n            onClick: (event) => {\n                var _a;\n                const triggerOnClick = (_a = trigger.props) === null || _a === void 0 ? void 0 : _a.onClick;\n                triggerOnClick === null || triggerOnClick === void 0 ? void 0 : triggerOnClick(event);\n                if (event.defaultPrevented)\n                    return;\n                changeOpen(true);\n            },\n        });\n    }, [changeOpen, trigger]);\n    const handleHide = useMemoizedFn((...args) => {\n        clearCloseTimer();\n        onOverlayHide === null || onOverlayHide === void 0 ? void 0 : onOverlayHide(...args);\n        changeOpen(false);\n    });\n    const shouldRenderPanel = mergedOpen || !destroyOnClose;\n    const mergedStyle = useMemo(() => (Object.assign(Object.assign({}, (overlayStyle || {})), (width !== undefined ? { width } : {}))), [overlayStyle, width]);\n    useEffect(() => {\n        return () => {\n            clearCloseTimer();\n        };\n    }, [clearCloseTimer]);\n    return {\n        mergedOpen,\n        shouldRenderPanel,\n        triggerNode,\n        handleFinish,\n        handleHide,\n        mergedStyle,\n        changeOpen,\n    };\n}"],"sourceRoot":"../../../../../../../../../../src"}

package/lib/components/ProForm/style/ProForm.module.css

@@ -0,0 +1 @@
+.proform__submitter{display:flex;gap:12px;margin-top:16px}.proform__drawer-form,.proform__modal-form{padding:16px;background:#fff;border:1px solid #e3e4e4;border-radius:12px}.proform__drawer-form-title,.proform__modal-form-title,.proform__steps-form-title{margin-bottom:12px;font-weight:600;font-size:16px;line-height:24px}.proform__steps-form-description{margin-bottom:12px;color:#646465;font-size:14px}.proform__query-filter-actions,.proform__steps-form-actions{display:flex;gap:8px;margin-top:16px}.proform__query-filter-split{padding-top:16px;border-top:1px solid #e3e4e4}.proform__list{display:flex;flex-direction:column;gap:12px}.proform__list-label{font-weight:600;font-size:14px}.proform__list-row-actions{display:flex;gap:8px}

package/lib/components/ProForm/style/ProForm.module.scss

@@ -0,0 +1,59 @@
+@use '../../../variable.scss' as *;
+/* stylelint-disable selector-pseudo-class-no-unknown */
+
+.proform__submitter {
+  display: flex;
+  gap: 12px;
+  margin-top: 16px;
+}
+
+.proform__modal-form,
+.proform__drawer-form {
+  padding: 16px;
+  background: $color-white;
+  border: 1px solid $color-grey-deep;
+  border-radius: 12px;
+}
+
+.proform__modal-form-title,
+.proform__drawer-form-title,
+.proform__steps-form-title {
+  margin-bottom: 12px;
+  font-weight: 600;
+  font-size: 16px;
+  line-height: 24px;
+}
+
+.proform__steps-form-description {
+  margin-bottom: 12px;
+  color: $color-grey-midnight;
+  font-size: 14px;
+}
+
+.proform__steps-form-actions,
+.proform__query-filter-actions {
+  display: flex;
+  gap: 8px;
+  margin-top: 16px;
+}
+
+.proform__query-filter-split {
+  padding-top: 16px;
+  border-top: 1px solid $color-grey-deep;
+}
+
+.proform__list {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+}
+
+.proform__list-label {
+  font-weight: 600;
+  font-size: 14px;
+}
+
+.proform__list-row-actions {
+  display: flex;
+  gap: 8px;
+}

package/lib/components/ProForm/style/css.js

@@ -0,0 +1,4 @@
+"use strict";
+
+require("./ProForm.module.css");
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvUHJvRm9ybS9zcmMvY29tcG9uZW50cy9Qcm9Gb3JtL3N0eWxlL2luZGV4LnRzIl0sIm5hbWVzIjpbInJlcXVpcmUiXSwibWFwcGluZ3MiOiI7O0FBQ0FBLE9BQUEiLCJmaWxlIjoiY29tcG9uZW50cy9Qcm9Gb3JtL3N0eWxlL2Nzcy5qcyIsInNvdXJjZXNDb250ZW50IjpbbnVsbF0sInNvdXJjZVJvb3QiOiIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMifQ==

package/lib/components/ProForm/style/index.d.ts

@@ -0,0 +1 @@
+import './ProForm.module.scss';

package/lib/components/ProForm/style/index.js

@@ -0,0 +1,4 @@
+"use strict";
+
+require("./ProForm.module.scss");
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvUHJvRm9ybS9zcmMvY29tcG9uZW50cy9Qcm9Gb3JtL3N0eWxlL2luZGV4LnRzIl0sIm5hbWVzIjpbInJlcXVpcmUiXSwibWFwcGluZ3MiOiI7O0FBQ0FBLE9BQUEiLCJmaWxlIjoiY29tcG9uZW50cy9Qcm9Gb3JtL3N0eWxlL2luZGV4LmpzIiwic291cmNlc0NvbnRlbnQiOltudWxsXSwic291cmNlUm9vdCI6Ii4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYyJ9

package/lib/components/ProForm/utils.d.ts

@@ -0,0 +1,72 @@
+import type { MouseEvent, ReactNode } from 'react';
+/** Shorthand for a generic key/value record. */
+export type UnknownRecord = Record<string, unknown>;
+/**
+ * Produces a deterministic, type-aware string key for deep comparison.
+ * Handles non-JSON-safe values (e.g. `undefined`, `symbol`, `function`) and circular references.
+ *
+ * @param value - The value to serialize.
+ * @returns A stable serialization key.
+ */
+export declare const stableSerialize: (value: unknown) => string;
+/**
+ * Renders a boolean value as localized "Yes" / "No" text for readonly mode.
+ *
+ * @param value - The field value.
+ * @returns The display string.
+ */
+export declare const renderBooleanReadonly: (value: unknown) => string;
+/**
+ * Renders a numeric value as its string representation, or a dash for empty values.
+ *
+ * @param value - The field value.
+ * @returns The display string.
+ */
+export declare const renderNumericReadonly: (value: unknown) => string;
+/**
+ * Renders a text value as-is, or a dash for empty values.
+ *
+ * @param value - The field value.
+ * @returns The display string.
+ */
+export declare const renderTextReadonly: (value: unknown) => string;
+/** Shape of an option item used by Select, Radio, and Checkbox fields. */
+interface OptionItem {
+    key?: unknown;
+    value?: unknown;
+    label?: unknown;
+}
+/**
+ * Finds the display label for a given value within an options array.
+ *
+ * @param value - The current field value.
+ * @param options - The list of available options.
+ * @param valueKey - Which option property to match against: `'value'`, `'key'`, or `'both'`.
+ * @returns The matched option's label, or the raw value, or a dash placeholder.
+ */
+export declare const findOptionLabel: (value: unknown, options: OptionItem[] | undefined, valueKey?: "value" | "key" | "both") => unknown;
+/**
+ * Type guard that checks whether a submitter configuration is enabled
+ * (i.e. not `false`, `null`, or `undefined`).
+ *
+ * @param submitter - The submitter prop value.
+ * @returns `true` if the submitter config object is present.
+ */
+export declare const isSubmitterEnabled: <T>(submitter: false | T | undefined) => submitter is T;
+type IconProps = false | UnknownRecord | undefined;
+/** Destructured button properties returned by {@link extractButtonProps}. */
+interface ExtractedButtonProps {
+    onClick: ((event: MouseEvent<HTMLButtonElement>) => void) | undefined;
+    disabled: boolean;
+    children: ReactNode;
+    domProps: UnknownRecord;
+}
+/**
+ * Extracts well-known button properties (`onClick`, `disabled`, `children`)
+ * from an icon-props configuration object, returning the remainder as `domProps`.
+ *
+ * @param props - The icon/button props, or `false`/`undefined` to skip.
+ * @returns A normalized {@link ExtractedButtonProps} object.
+ */
+export declare const extractButtonProps: (props: IconProps) => ExtractedButtonProps;
+export {};

package/lib/components/ProForm/utils.js

@@ -0,0 +1,213 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.stableSerialize = exports.renderTextReadonly = exports.renderNumericReadonly = exports.renderBooleanReadonly = exports.isSubmitterEnabled = exports.findOptionLabel = exports.extractButtonProps = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _constants = require("./constants");
+var __rest = void 0 && (void 0).__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;
+};
+var getNextSeenId = function getNextSeenId(ctx) {
+  var current = ctx.nextId;
+  ctx.nextId += 1;
+  return current;
+};
+var sortObjectKeys = function sortObjectKeys(value) {
+  return Reflect.ownKeys(value).map(function (rawKey) {
+    var _a;
+    return {
+      rawKey: rawKey,
+      serializedKey: (0, _typeof2["default"])(rawKey) === 'symbol' ? "@@symbol:".concat(String((_a = rawKey.description) !== null && _a !== void 0 ? _a : rawKey)) : String(rawKey)
+    };
+  }).sort(function (a, b) {
+    return a.serializedKey.localeCompare(b.serializedKey);
+  });
+};
+var serializeNumber = function serializeNumber(value) {
+  if (Number.isNaN(value)) return 'number:NaN';
+  if (!Number.isFinite(value)) return "number:".concat(value > 0 ? 'Infinity' : '-Infinity');
+  return "number:".concat(String(value));
+};
+var serializeObject = function serializeObject(value, ctx) {
+  var _a, _b;
+  if (ctx.seen.has(value)) {
+    return "ref:".concat(ctx.seen.get(value));
+  }
+  var id = getNextSeenId(ctx);
+  ctx.seen.set(value, id);
+  if (Array.isArray(value)) {
+    return "array:[".concat(value.map(function (item) {
+      return serializeStableValue(item, ctx);
+    }).join(','), "]");
+  }
+  if (value instanceof Date) {
+    return "date:".concat(Number.isNaN(value.getTime()) ? 'Invalid Date' : value.toISOString());
+  }
+  if (value instanceof RegExp) {
+    return "regexp:".concat(value.toString());
+  }
+  if (value instanceof Set) {
+    var values = Array.from(value.values()).map(function (item) {
+      return serializeStableValue(item, ctx);
+    }).sort();
+    return "set:{".concat(values.join(','), "}");
+  }
+  if (value instanceof Map) {
+    var entries = Array.from(value.entries()).map(function (_ref) {
+      var _ref2 = (0, _slicedToArray2["default"])(_ref, 2),
+        key = _ref2[0],
+        item = _ref2[1];
+      return {
+        key: serializeStableValue(key, ctx),
+        value: serializeStableValue(item, ctx)
+      };
+    }).sort(function (a, b) {
+      if (a.key === b.key) return a.value.localeCompare(b.value);
+      return a.key.localeCompare(b.key);
+    });
+    return "map:{".concat(entries.map(function (entry) {
+      return "".concat(entry.key, "->").concat(entry.value);
+    }).join(','), "}");
+  }
+  var constructorName = (_b = (_a = value.constructor) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : 'Object';
+  var keys = sortObjectKeys(value);
+  var serializedPairs = keys.map(function (_ref3) {
+    var rawKey = _ref3.rawKey,
+      serializedKey = _ref3.serializedKey;
+    var nextValue = value[rawKey];
+    return "".concat(serializedKey, ":").concat(serializeStableValue(nextValue, ctx));
+  });
+  return "object:".concat(constructorName, ":{").concat(serializedPairs.join(','), "}");
+};
+var serializeStableValue = function serializeStableValue(value, ctx) {
+  var _a;
+  if (value === null) return 'null';
+  switch ((0, _typeof2["default"])(value)) {
+    case 'undefined':
+      return 'undefined';
+    case 'string':
+      return "string:".concat(JSON.stringify(value));
+    case 'number':
+      return serializeNumber(value);
+    case 'boolean':
+      return "boolean:".concat(value ? '1' : '0');
+    case 'bigint':
+      return "bigint:".concat(String(value));
+    case 'symbol':
+      return "symbol:".concat(String((_a = value.description) !== null && _a !== void 0 ? _a : value));
+    case 'function':
+      {
+        var fn = value;
+        return "function:".concat(fn.name || 'anonymous', ":").concat(fn.length, ":").concat(String(fn));
+      }
+    case 'object':
+      return serializeObject(value, ctx);
+    default:
+      return "unknown:".concat(String(value));
+  }
+};
+/**
+ * Produces a deterministic, type-aware string key for deep comparison.
+ * Handles non-JSON-safe values (e.g. `undefined`, `symbol`, `function`) and circular references.
+ *
+ * @param value - The value to serialize.
+ * @returns A stable serialization key.
+ */
+var stableSerialize = exports.stableSerialize = function stableSerialize(value) {
+  try {
+    return serializeStableValue(value, {
+      seen: new WeakMap(),
+      nextId: 0
+    });
+  } catch (error) {
+    var message = error instanceof Error ? error.message : String(error);
+    return "serialization-error:".concat(message);
+  }
+};
+/**
+ * Renders a boolean value as localized "Yes" / "No" text for readonly mode.
+ *
+ * @param value - The field value.
+ * @returns The display string.
+ */
+var renderBooleanReadonly = exports.renderBooleanReadonly = function renderBooleanReadonly(value) {
+  return value ? _constants.DEFAULT_TEXT.yes : _constants.DEFAULT_TEXT.no;
+};
+/**
+ * Renders a numeric value as its string representation, or a dash for empty values.
+ *
+ * @param value - The field value.
+ * @returns The display string.
+ */
+var renderNumericReadonly = exports.renderNumericReadonly = function renderNumericReadonly(value) {
+  return value == null || value === '' ? _constants.DEFAULT_TEXT.empty : String(value);
+};
+/**
+ * Renders a text value as-is, or a dash for empty values.
+ *
+ * @param value - The field value.
+ * @returns The display string.
+ */
+var renderTextReadonly = exports.renderTextReadonly = function renderTextReadonly(value) {
+  return value != null && value !== '' ? String(value) : _constants.DEFAULT_TEXT.empty;
+};
+/**
+ * Finds the display label for a given value within an options array.
+ *
+ * @param value - The current field value.
+ * @param options - The list of available options.
+ * @param valueKey - Which option property to match against: `'value'`, `'key'`, or `'both'`.
+ * @returns The matched option's label, or the raw value, or a dash placeholder.
+ */
+var findOptionLabel = exports.findOptionLabel = function findOptionLabel(value, options) {
+  var valueKey = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'value';
+  var _a, _b;
+  if (!Array.isArray(options)) return value !== null && value !== void 0 ? value : _constants.DEFAULT_TEXT.empty;
+  var matched = options.find(function (item) {
+    if (valueKey === 'both') {
+      return (item === null || item === void 0 ? void 0 : item.key) === value || (item === null || item === void 0 ? void 0 : item.value) === value;
+    }
+    return (item === null || item === void 0 ? void 0 : item[valueKey]) === value;
+  });
+  return (_b = (_a = matched === null || matched === void 0 ? void 0 : matched.label) !== null && _a !== void 0 ? _a : value) !== null && _b !== void 0 ? _b : _constants.DEFAULT_TEXT.empty;
+};
+/**
+ * Type guard that checks whether a submitter configuration is enabled
+ * (i.e. not `false`, `null`, or `undefined`).
+ *
+ * @param submitter - The submitter prop value.
+ * @returns `true` if the submitter config object is present.
+ */
+var isSubmitterEnabled = exports.isSubmitterEnabled = function isSubmitterEnabled(submitter) {
+  return submitter !== false && submitter != null;
+};
+/**
+ * Extracts well-known button properties (`onClick`, `disabled`, `children`)
+ * from an icon-props configuration object, returning the remainder as `domProps`.
+ *
+ * @param props - The icon/button props, or `false`/`undefined` to skip.
+ * @returns A normalized {@link ExtractedButtonProps} object.
+ */
+var extractButtonProps = exports.extractButtonProps = function extractButtonProps(props) {
+  var btnProps = props && (0, _typeof2["default"])(props) === 'object' ? props : {};
+  var onClick = btnProps.onClick,
+    disabled = btnProps.disabled,
+    children = btnProps.children,
+    domProps = __rest(btnProps, ["onClick", "disabled", "children"]);
+  return {
+    onClick: onClick,
+    disabled: !!disabled,
+    children: children,
+    domProps: domProps
+  };
+};
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/src/components/ProForm/utils.ts","components/ProForm/utils.js"],"names":["_constants","require","__rest","s","e","t","p","Object","prototype","hasOwnProperty","call","indexOf","getOwnPropertySymbols","i","length","propertyIsEnumerable","getNextSeenId","ctx","current","nextId","sortObjectKeys","value","Reflect","ownKeys","map","rawKey","_a","serializedKey","_typeof2","concat","String","description","sort","a","b","localeCompare","serializeNumber","Number","isNaN","isFinite","serializeObject","_b","seen","has","get","id","set","Array","isArray","item","serializeStableValue","join","Date","getTime","toISOString","RegExp","toString","Set","values","from","Map","entries","_ref","_ref2","_slicedToArray2","key","entry","constructorName","constructor","name","keys","serializedPairs","_ref3","nextValue","JSON","stringify","fn","stableSerialize","exports","WeakMap","error","message","Error","renderBooleanReadonly","DEFAULT_TEXT","yes","no","renderNumericReadonly","empty","renderTextReadonly","findOptionLabel","options","valueKey","arguments","undefined","matched","find","label","isSubmitterEnabled","submitter","extractButtonProps","props","btnProps","onClick","disabled","children","domProps"],"mappings":"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","file":"components/ProForm/utils.js","sourcesContent":[null,"var __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 { DEFAULT_TEXT } from './constants';\nconst getNextSeenId = (ctx) => {\n    const current = ctx.nextId;\n    ctx.nextId += 1;\n    return current;\n};\nconst sortObjectKeys = (value) => {\n    return Reflect.ownKeys(value)\n        .map((rawKey) => {\n        var _a;\n        return ({\n            rawKey,\n            serializedKey: typeof rawKey === 'symbol'\n                ? `@@symbol:${String((_a = rawKey.description) !== null && _a !== void 0 ? _a : rawKey)}`\n                : String(rawKey),\n        });\n    })\n        .sort((a, b) => a.serializedKey.localeCompare(b.serializedKey));\n};\nconst serializeNumber = (value) => {\n    if (Number.isNaN(value))\n        return 'number:NaN';\n    if (!Number.isFinite(value))\n        return `number:${value > 0 ? 'Infinity' : '-Infinity'}`;\n    return `number:${String(value)}`;\n};\nconst serializeObject = (value, ctx) => {\n    var _a, _b;\n    if (ctx.seen.has(value)) {\n        return `ref:${ctx.seen.get(value)}`;\n    }\n    const id = getNextSeenId(ctx);\n    ctx.seen.set(value, id);\n    if (Array.isArray(value)) {\n        return `array:[${value.map(item => serializeStableValue(item, ctx)).join(',')}]`;\n    }\n    if (value instanceof Date) {\n        return `date:${Number.isNaN(value.getTime()) ? 'Invalid Date' : value.toISOString()}`;\n    }\n    if (value instanceof RegExp) {\n        return `regexp:${value.toString()}`;\n    }\n    if (value instanceof Set) {\n        const values = Array.from(value.values())\n            .map(item => serializeStableValue(item, ctx))\n            .sort();\n        return `set:{${values.join(',')}}`;\n    }\n    if (value instanceof Map) {\n        const entries = Array.from(value.entries())\n            .map(([key, item]) => ({\n            key: serializeStableValue(key, ctx),\n            value: serializeStableValue(item, ctx),\n        }))\n            .sort((a, b) => {\n            if (a.key === b.key)\n                return a.value.localeCompare(b.value);\n            return a.key.localeCompare(b.key);\n        });\n        return `map:{${entries.map(entry => `${entry.key}->${entry.value}`).join(',')}}`;\n    }\n    const constructorName = (_b = (_a = value.constructor) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : 'Object';\n    const keys = sortObjectKeys(value);\n    const serializedPairs = keys.map(({ rawKey, serializedKey }) => {\n        const nextValue = value[rawKey];\n        return `${serializedKey}:${serializeStableValue(nextValue, ctx)}`;\n    });\n    return `object:${constructorName}:{${serializedPairs.join(',')}}`;\n};\nconst serializeStableValue = (value, ctx) => {\n    var _a;\n    if (value === null)\n        return 'null';\n    switch (typeof value) {\n        case 'undefined':\n            return 'undefined';\n        case 'string':\n            return `string:${JSON.stringify(value)}`;\n        case 'number':\n            return serializeNumber(value);\n        case 'boolean':\n            return `boolean:${value ? '1' : '0'}`;\n        case 'bigint':\n            return `bigint:${String(value)}`;\n        case 'symbol':\n            return `symbol:${String((_a = value.description) !== null && _a !== void 0 ? _a : value)}`;\n        case 'function': {\n            const fn = value;\n            return `function:${fn.name || 'anonymous'}:${fn.length}:${String(fn)}`;\n        }\n        case 'object':\n            return serializeObject(value, ctx);\n        default:\n            return `unknown:${String(value)}`;\n    }\n};\n/**\n * Produces a deterministic, type-aware string key for deep comparison.\n * Handles non-JSON-safe values (e.g. `undefined`, `symbol`, `function`) and circular references.\n *\n * @param value - The value to serialize.\n * @returns A stable serialization key.\n */\nexport const stableSerialize = (value) => {\n    try {\n        return serializeStableValue(value, { seen: new WeakMap(), nextId: 0 });\n    }\n    catch (error) {\n        const message = error instanceof Error ? error.message : String(error);\n        return `serialization-error:${message}`;\n    }\n};\n/**\n * Renders a boolean value as localized \"Yes\" / \"No\" text for readonly mode.\n *\n * @param value - The field value.\n * @returns The display string.\n */\nexport const renderBooleanReadonly = (value) => value ? DEFAULT_TEXT.yes : DEFAULT_TEXT.no;\n/**\n * Renders a numeric value as its string representation, or a dash for empty values.\n *\n * @param value - The field value.\n * @returns The display string.\n */\nexport const renderNumericReadonly = (value) => value == null || value === '' ? DEFAULT_TEXT.empty : String(value);\n/**\n * Renders a text value as-is, or a dash for empty values.\n *\n * @param value - The field value.\n * @returns The display string.\n */\nexport const renderTextReadonly = (value) => value != null && value !== '' ? String(value) : DEFAULT_TEXT.empty;\n/**\n * Finds the display label for a given value within an options array.\n *\n * @param value - The current field value.\n * @param options - The list of available options.\n * @param valueKey - Which option property to match against: `'value'`, `'key'`, or `'both'`.\n * @returns The matched option's label, or the raw value, or a dash placeholder.\n */\nexport const findOptionLabel = (value, options, valueKey = 'value') => {\n    var _a, _b;\n    if (!Array.isArray(options))\n        return value !== null && value !== void 0 ? value : DEFAULT_TEXT.empty;\n    const matched = options.find((item) => {\n        if (valueKey === 'both') {\n            return (item === null || item === void 0 ? void 0 : item.key) === value || (item === null || item === void 0 ? void 0 : item.value) === value;\n        }\n        return (item === null || item === void 0 ? void 0 : item[valueKey]) === value;\n    });\n    return (_b = (_a = matched === null || matched === void 0 ? void 0 : matched.label) !== null && _a !== void 0 ? _a : value) !== null && _b !== void 0 ? _b : DEFAULT_TEXT.empty;\n};\n/**\n * Type guard that checks whether a submitter configuration is enabled\n * (i.e. not `false`, `null`, or `undefined`).\n *\n * @param submitter - The submitter prop value.\n * @returns `true` if the submitter config object is present.\n */\nexport const isSubmitterEnabled = (submitter) => submitter !== false && submitter != null;\n/**\n * Extracts well-known button properties (`onClick`, `disabled`, `children`)\n * from an icon-props configuration object, returning the remainder as `domProps`.\n *\n * @param props - The icon/button props, or `false`/`undefined` to skip.\n * @returns A normalized {@link ExtractedButtonProps} object.\n */\nexport const extractButtonProps = (props) => {\n    const btnProps = props && typeof props === 'object' ? props : {};\n    const { onClick, disabled, children } = btnProps, domProps = __rest(btnProps, [\"onClick\", \"disabled\", \"children\"]);\n    return {\n        onClick: onClick,\n        disabled: !!disabled,\n        children: children,\n        domProps,\n    };\n};"],"sourceRoot":"../../../../../../../../../src"}