@1money/component-ui 0.0.71 → 0.0.74

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

@@ -1,13 +1,40 @@
-import type { ProFormContextValue, FormListContextValue, ProFormFormInstance } from './interface';
-export declare const ProFormContext: import("react").Context<ProFormContextValue | null>;
+import type { FormStore } from './core/formStore';
+import type { ProFormContextValue, ProFormStableContextValue, ProFormStateContextValue, FormListContextValue, ProFormFormInstance } from './interface';
+export declare const ProFormStableContext: import("react").Context<ProFormStableContextValue | null>;
+export declare const ProFormStateContext: import("react").Context<FormStore | null>;
+/** Read ONLY the stable slice (config + dispatchers) — no per-keystroke re-renders. */
+export declare const useProFormStable: () => ProFormStableContextValue;
+/**
+ * Internal: the raw form store (identity-stable — reading it never causes
+ * re-renders by itself). Pair with `useStoreSelector` for fine-grained,
+ * per-field subscriptions. Throws when used outside `<ProForm>`.
+ */
+export declare const useProFormStore: () => FormStore;
+/** Read ONLY the volatile slice (values/errors/…) — re-renders on every change. */
+export declare const useProFormState: () => ProFormStateContextValue;
 /**
  * Read the unified ProForm context (merged form core + ProForm semantics).
+ * Subscribes to BOTH slices — re-renders whenever form values change.
  * Throws when used outside `<ProForm>`.
  */
 export declare const useProFormContext: () => ProFormContextValue;
 /**
  * Read the ProForm form instance (superset of FormCoreInstance with format helpers).
+ * Subscribes only to the stable slice — does NOT re-render per keystroke.
+ * Pass a `Values` type argument to get a typed instance.
+ */
+export declare const useFormInstance: <Values = Record<string, unknown>>() => ProFormFormInstance<Values>;
+export interface UseFormWatch {
+    /** Watch a single field; dot-paths supported (e.g. `"address.city"`). */
+    (name: string): unknown;
+    /** Watch the whole values object. */
+    (): Record<string, unknown>;
+}
+/**
+ * Watch a single field or the whole values object. Re-renders whenever the
+ * WATCHED value changes (unrelated fields no longer cause re-renders).
+ * Lighter alternative to the `ProForm.Dependency` render-prop.
  */
-export declare const useFormInstance: () => ProFormFormInstance;
+export declare const useFormWatch: UseFormWatch;
 export declare const FormListContext: import("react").Context<FormListContextValue>;
 export declare const useFormListContext: () => FormListContextValue;

package/es/components/ProForm/context.js

@@ -1,22 +1,81 @@
-import { createContext, useContext } from 'react';
-export var ProFormContext = /*#__PURE__*/createContext(null);
-ProFormContext.displayName = 'ProFormContext';
+import { createContext, useContext, useMemo } from 'react';
+import { resolveValue } from './core/pathUtils';
+import { useStoreSelector } from './core/formStore';
+// ---------------------------------------------------------------------------
+// The ProForm context is SPLIT in two so that consumers which only need
+// configuration / dispatchers (Submitter, field factories) do not re-render
+// on every keystroke:
+// - StableContext: config + identity-stable dispatchers and form instance.
+// - StateContext: holds the IDENTITY-STABLE form store, never a snapshot —
+//   per-keystroke updates reach subscribers through store subscriptions
+//   (useStoreSelector with per-field selectors), not context propagation.
+// ---------------------------------------------------------------------------
+export var ProFormStableContext = /*#__PURE__*/createContext(null);
+ProFormStableContext.displayName = 'ProFormStableContext';
+export var ProFormStateContext = /*#__PURE__*/createContext(null);
+ProFormStateContext.displayName = 'ProFormStateContext';
+var OUTSIDE_FORM_ERROR = 'useProFormContext must be used within a <ProForm> component';
+/** Read ONLY the stable slice (config + dispatchers) — no per-keystroke re-renders. */
+export var useProFormStable = function useProFormStable() {
+  var ctx = useContext(ProFormStableContext);
+  if (!ctx) {
+    throw new Error(OUTSIDE_FORM_ERROR);
+  }
+  return ctx;
+};
+/**
+ * Internal: the raw form store (identity-stable — reading it never causes
+ * re-renders by itself). Pair with `useStoreSelector` for fine-grained,
+ * per-field subscriptions. Throws when used outside `<ProForm>`.
+ */
+export var useProFormStore = function useProFormStore() {
+  var store = useContext(ProFormStateContext);
+  if (!store) {
+    throw new Error(OUTSIDE_FORM_ERROR);
+  }
+  return store;
+};
+var selectStateSnapshot = function selectStateSnapshot(state) {
+  return state;
+};
+/** Read ONLY the volatile slice (values/errors/…) — re-renders on every change. */
+export var useProFormState = function useProFormState() {
+  var store = useProFormStore();
+  // Subscribe to every commit (the snapshot identity changes per commit) —
+  // that broad granularity is this hook's documented contract; fine-grained
+  // consumers use useStoreSelector with a narrower selector instead.
+  return useStoreSelector(store, selectStateSnapshot);
+};
 /**
  * Read the unified ProForm context (merged form core + ProForm semantics).
+ * Subscribes to BOTH slices — re-renders whenever form values change.
  * Throws when used outside `<ProForm>`.
  */
 export var useProFormContext = function useProFormContext() {
-  var ctx = useContext(ProFormContext);
-  if (!ctx) {
-    throw new Error('useProFormContext must be used within a <ProForm> component');
-  }
-  return ctx;
+  var stable = useProFormStable();
+  var state = useProFormState();
+  return useMemo(function () {
+    return Object.assign(Object.assign({}, stable), state);
+  }, [stable, state]);
 };
 /**
  * Read the ProForm form instance (superset of FormCoreInstance with format helpers).
+ * Subscribes only to the stable slice — does NOT re-render per keystroke.
+ * Pass a `Values` type argument to get a typed instance.
  */
 export var useFormInstance = function useFormInstance() {
-  return useProFormContext().formInstance;
+  return useProFormStable().formInstance;
+};
+/**
+ * Watch a single field or the whole values object. Re-renders whenever the
+ * WATCHED value changes (unrelated fields no longer cause re-renders).
+ * Lighter alternative to the `ProForm.Dependency` render-prop.
+ */
+export var useFormWatch = function useFormWatch(name) {
+  var store = useProFormStore();
+  return useStoreSelector(store, function (state) {
+    return name === undefined ? state.values : resolveValue(state.values, name);
+  });
 };
 // ---------------------------------------------------------------------------
 // FormListContext — provides list scope info to ProFormDependency
@@ -26,4 +85,4 @@ FormListContext.displayName = 'FormListContext';
 export var useFormListContext = function useFormListContext() {
   return useContext(FormListContext);
 };
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/src/components/ProForm/context.ts","components/ProForm/context.js"],"names":["createContext","useContext","useMemo","resolveValue","useStoreSelector","ProFormStableContext","displayName","ProFormStateContext","OUTSIDE_FORM_ERROR","useProFormStable","ctx","Error","useProFormStore","store","selectStateSnapshot","state","useProFormState","useProFormContext","stable","Object","assign","useFormInstance","formInstance","useFormWatch","name","undefined","values","FormListContext","useFormListContext"],"mappings":"AAAA,SAASA,aAAa,EAAEC,UAAU,EAAEC,OAAO,QAAQ,OAAO;AAC1D,SAASC,YAAY,QAAQ,kBAAkB;AAC/C,SAASC,gBAAgB,QAAQ,kBAAkB;AAUnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,IAAMC,oBAAoB,gBAAGL,aAAa,CAAmC,IAAI,CAAC;AACzFK,oBAAoB,CAACC,WAAW,GAAG,sBAAsB;AAEzD,OAAO,IAAMC,mBAAmB,gBAAGP,aAAa,CAAmB,IAAI,CAAC;AACxEO,mBAAmB,CAACD,WAAW,GAAG,qBAAqB;AAEvD,IAAME,kBAAkB,GAAG,6DAA6D;AAExF;AACA,OAAO,IAAMC,gBAAgB,GAAG,SAAnBA,gBAAgBA,CAAA,EAAmC;EAC9D,IAAMC,GAAG,GAAGT,UAAU,CAACI,oBAAoB,CAAC;EAC5C,IAAI,CAACK,GAAG,EAAE;IACR,MAAM,IAAIC,KAAK,CAACH,kBAAkB,CAAC;EACrC;EACA,OAAOE,GAAG;AACZ,CAAC;AAED;ACZA;AACA;AACA;AACA;ADcA,OAAO,IAAME,eAAe,GAAG,SAAlBA,eAAeA,CAAA,EAAmB;EAC7C,IAAMC,KAAK,GAAGZ,UAAU,CAACM,mBAAmB,CAAC;EAC7C,IAAI,CAACM,KAAK,EAAE;IACV,MAAM,IAAIF,KAAK,CAACH,kBAAkB,CAAC;EACrC;EACA,OAAOK,KAAK;AACd,CAAC;AAED,IAAMC,mBAAmB,GAAG,SAAtBA,mBAAmBA,CAAIC,KAAqB;EAAA,OAA+BA,KAAK;AAAA;AAEtF;AACA,OAAO,IAAMC,eAAe,GAAG,SAAlBA,eAAeA,CAAA,EAAkC;EAC5D,IAAMH,KAAK,GAAGD,eAAe,CAAA,CAAE;EAC/B;EACA;EACA;EACA,OAAOR,gBAAgB,CAACS,KAAK,EAAEC,mBAAmB,CAAC;AACrD,CAAC;AAED;ACfA;AACA;AACA;AACA;ADiBA,OAAO,IAAMG,iBAAiB,GAAG,SAApBA,iBAAiBA,CAAA,EAA6B;EACzD,IAAMC,MAAM,GAAGT,gBAAgB,CAAA,CAAE;EACjC,IAAMM,KAAK,GAAGC,eAAe,CAAA,CAAE;EAC/B,OAAOd,OAAO,CAAC;IAAA,OAAMiB,MAAA,CAAAC,MAAA,CAAAD,MAAA,CAAAC,MAAA,CAAA,CAAA,CAAA,EAAMF,MAAM,CAAA,EAAKH,KAAK,CAAA;EAAA,CAAG,EAAE,CAACG,MAAM,EAAEH,KAAK,CAAC,CAAC;AAClE,CAAC;AAED;AChBA;AACA;AACA;AACA;ADkBA,OAAO,IAAMM,eAAe,GAAG,SAAlBA,eAAeA,CAAA,EAAuE;EACjG,OAAOZ,gBAAgB,CAAA,CAAE,CAACa,YAA2C;AACvE,CAAC;AASD;ACxBA;AACA;AACA;AACA;AD0BA,OAAO,IAAMC,YAAY,GAAkB,SAA9BA,YAAYA,CAAmBC,IAAa,EAAI;EAC3D,IAAMX,KAAK,GAAGD,eAAe,CAAA,CAAE;EAC/B,OAAOR,gBAAgB,CAACS,KAAK,EAAE,UAACE,KAAK;IAAA,OACnCS,IAAI,KAAKC,SAAS,GAAGV,KAAK,CAACW,MAAM,GAAGvB,YAAY,CAACY,KAAK,CAACW,MAAM,EAAEF,IAAI,CAAC;EAAA,EACrE;AACH,CAAkB;AAElB;AACA;AACA;AACA,OAAO,IAAMG,eAAe,gBAAG3B,aAAa,CAAuB,CAAA,CAAE,CAAC;AAEtE2B,eAAe,CAACrB,WAAW,GAAG,iBAAiB;AAE/C,OAAO,IAAMsB,kBAAkB,GAAG,SAArBA,kBAAkBA,CAAA;EAAA,OAA+B3B,UAAU,CAAC0B,eAAe,CAAC;AAAA","file":"components/ProForm/context.js","sourcesContent":[null,"import { createContext, useContext, useMemo } from 'react';\nimport { resolveValue } from './core/pathUtils';\nimport { useStoreSelector } from './core/formStore';\n// ---------------------------------------------------------------------------\n// The ProForm context is SPLIT in two so that consumers which only need\n// configuration / dispatchers (Submitter, field factories) do not re-render\n// on every keystroke:\n// - StableContext: config + identity-stable dispatchers and form instance.\n// - StateContext: holds the IDENTITY-STABLE form store, never a snapshot —\n//   per-keystroke updates reach subscribers through store subscriptions\n//   (useStoreSelector with per-field selectors), not context propagation.\n// ---------------------------------------------------------------------------\nexport const ProFormStableContext = createContext(null);\nProFormStableContext.displayName = 'ProFormStableContext';\nexport const ProFormStateContext = createContext(null);\nProFormStateContext.displayName = 'ProFormStateContext';\nconst OUTSIDE_FORM_ERROR = 'useProFormContext must be used within a <ProForm> component';\n/** Read ONLY the stable slice (config + dispatchers) — no per-keystroke re-renders. */\nexport const useProFormStable = () => {\n    const ctx = useContext(ProFormStableContext);\n    if (!ctx) {\n        throw new Error(OUTSIDE_FORM_ERROR);\n    }\n    return ctx;\n};\n/**\n * Internal: the raw form store (identity-stable — reading it never causes\n * re-renders by itself). Pair with `useStoreSelector` for fine-grained,\n * per-field subscriptions. Throws when used outside `<ProForm>`.\n */\nexport const useProFormStore = () => {\n    const store = useContext(ProFormStateContext);\n    if (!store) {\n        throw new Error(OUTSIDE_FORM_ERROR);\n    }\n    return store;\n};\nconst selectStateSnapshot = (state) => state;\n/** Read ONLY the volatile slice (values/errors/…) — re-renders on every change. */\nexport const useProFormState = () => {\n    const store = useProFormStore();\n    // Subscribe to every commit (the snapshot identity changes per commit) —\n    // that broad granularity is this hook's documented contract; fine-grained\n    // consumers use useStoreSelector with a narrower selector instead.\n    return useStoreSelector(store, selectStateSnapshot);\n};\n/**\n * Read the unified ProForm context (merged form core + ProForm semantics).\n * Subscribes to BOTH slices — re-renders whenever form values change.\n * Throws when used outside `<ProForm>`.\n */\nexport const useProFormContext = () => {\n    const stable = useProFormStable();\n    const state = useProFormState();\n    return useMemo(() => (Object.assign(Object.assign({}, stable), state)), [stable, state]);\n};\n/**\n * Read the ProForm form instance (superset of FormCoreInstance with format helpers).\n * Subscribes only to the stable slice — does NOT re-render per keystroke.\n * Pass a `Values` type argument to get a typed instance.\n */\nexport const useFormInstance = () => {\n    return useProFormStable().formInstance;\n};\n/**\n * Watch a single field or the whole values object. Re-renders whenever the\n * WATCHED value changes (unrelated fields no longer cause re-renders).\n * Lighter alternative to the `ProForm.Dependency` render-prop.\n */\nexport const useFormWatch = ((name) => {\n    const store = useProFormStore();\n    return useStoreSelector(store, (state) => name === undefined ? state.values : resolveValue(state.values, name));\n});\n// ---------------------------------------------------------------------------\n// FormListContext — provides list scope info to ProFormDependency\n// ---------------------------------------------------------------------------\nexport const FormListContext = createContext({});\nFormListContext.displayName = 'FormListContext';\nexport const useFormListContext = () => useContext(FormListContext);"],"sourceRoot":"../../../../../../../../../src"}

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

@@ -1,5 +1,5 @@
 import type { TypographyBodySize, TypographyColor, TypographyLabelSize } from "../../Typography";
-export declare const FORM_SIZES: readonly ["large", "middle", "small"];
+export declare const FORM_SIZES: readonly ["large", "small"];
 export declare const FORM_LAYOUTS: readonly ["vertical"];
 export declare const LABEL_ALIGNS: readonly ["left", "right"];
 export declare const VALIDATE_STATUSES: readonly ["success", "warning", "error", "validating"];
@@ -9,16 +9,25 @@ export type FormLayout = (typeof FORM_LAYOUTS)[number];
 export type LabelAlign = (typeof LABEL_ALIGNS)[number];
 export type ValidateStatus = (typeof VALIDATE_STATUSES)[number];
 export type ValidateTrigger = (typeof VALIDATE_TRIGGERS)[number];
-export declare const FORM_ITEM_SPACING: Record<FormSize, string>;
-export declare const FORM_LABEL_SIZE: TypographyLabelSize;
+export declare const FORM_LABEL_SIZES: Record<FormSize, TypographyLabelSize>;
 export declare const FORM_LABEL_COLOR: TypographyColor;
 export declare const FORM_ERROR_SIZE: TypographyBodySize;
 export declare const FORM_ERROR_COLOR: TypographyColor;
+export declare const FORM_WARNING_SIZE: TypographyBodySize;
+export declare const FORM_WARNING_COLOR: TypographyColor;
 export declare const FORM_DESCRIPTION_SIZE: TypographyBodySize;
 export declare const FORM_DESCRIPTION_COLOR: TypographyColor;
 export declare const FORM_FEEDBACK_SIZE: TypographyBodySize;
 export declare const FORM_FEEDBACK_COLOR: TypographyColor;
 export declare const FORM_COMPONENT_NAMES: readonly ["Input", "InputNumber", "InputPassword", "InputTextArea", "InputSearch", "InputOTP", "InputTrade", "InputAmount", "InputMask", "Select", "BaseSelect", "DatePicker", "TimePicker", "Calendar", "Checkbox", "CheckboxGroup", "Radio", "RadioGroup", "Switch", "Slider", "TextArea"];
+/**
+ * Form controls that declare a `size` prop accepting `'large' | 'small'`.
+ * `injectField` cascades the form-level `size` into these as a DEFAULT — an
+ * explicit field-level `size` (own prop or via `fieldProps`) wins. Controls
+ * without a size prop (Checkbox, Switch, Slider, …) must stay off this list:
+ * an unknown `size` prop could leak onto the DOM element.
+ */
+export declare const SIZE_AWARE_COMPONENT_NAMES: readonly string[];
 /**
  * Text-like form controls whose empty value must default to '' (a controlled
  * string input) rather than undefined. Used by `injectField` to pick a safe

package/es/components/ProForm/core/constants.js

@@ -1,26 +1,37 @@
-export var FORM_SIZES = ['large', 'middle', 'small'];
+export var FORM_SIZES = ['large', 'small'];
 export var FORM_LAYOUTS = ['vertical'];
 export var LABEL_ALIGNS = ['left', 'right'];
 export var VALIDATE_STATUSES = ['success', 'warning', 'error', 'validating'];
 export var VALIDATE_TRIGGERS = ['onChange', 'onBlur'];
-export var FORM_ITEM_SPACING = {
-  large: '300',
-  middle: '300',
-  small: '200'
+// Label typography pairs with the field control's text size for each form
+// size: large control text is body/lg (16px) → label lg; small is body/md
+// (14px) → label md.
+export var FORM_LABEL_SIZES = {
+  large: 'lg',
+  small: 'md'
 };
-export var FORM_LABEL_SIZE = 'lg';
 export var FORM_LABEL_COLOR = 'default';
 export var FORM_ERROR_SIZE = 'sm';
 export var FORM_ERROR_COLOR = 'danger';
+export var FORM_WARNING_SIZE = 'sm';
+export var FORM_WARNING_COLOR = 'warning';
 export var FORM_DESCRIPTION_SIZE = 'md';
 export var FORM_DESCRIPTION_COLOR = 'default-tertiary';
 export var FORM_FEEDBACK_SIZE = 'sm';
 export var FORM_FEEDBACK_COLOR = 'default-tertiary';
 export var FORM_COMPONENT_NAMES = ['Input', 'InputNumber', 'InputPassword', 'InputTextArea', 'InputSearch', 'InputOTP', 'InputTrade', 'InputAmount', 'InputMask', 'Select', 'BaseSelect', 'DatePicker', 'TimePicker', 'Calendar', 'Checkbox', 'CheckboxGroup', 'Radio', 'RadioGroup', 'Switch', 'Slider', 'TextArea'];
+/**
+ * Form controls that declare a `size` prop accepting `'large' | 'small'`.
+ * `injectField` cascades the form-level `size` into these as a DEFAULT — an
+ * explicit field-level `size` (own prop or via `fieldProps`) wins. Controls
+ * without a size prop (Checkbox, Switch, Slider, …) must stay off this list:
+ * an unknown `size` prop could leak onto the DOM element.
+ */
+export var SIZE_AWARE_COMPONENT_NAMES = ['Input', 'InputPassword', 'InputTextArea', 'InputSearch', 'InputOTP', 'InputAmount', 'InputMask', 'Select', 'Calendar', 'Radio', 'RadioGroup'];
 /**
  * Text-like form controls whose empty value must default to '' (a controlled
  * string input) rather than undefined. Used by `injectField` to pick a safe
  * fallback value.
  */
 export var TEXT_LIKE_COMPONENT_NAMES = ['Input', 'InputPassword', 'InputTextArea', 'InputSearch', 'InputOTP', 'InputTrade', 'InputAmount', 'InputMask', 'TextArea', 'InputNumber'];
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

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

@@ -0,0 +1,24 @@
+export interface FormStoreState {
+    values: Record<string, unknown>;
+    errors: Record<string, string>;
+    warnings: Record<string, string>;
+    touched: Record<string, boolean>;
+    validating: Record<string, boolean>;
+}
+export type FormStoreListener = () => void;
+export interface FormStore {
+    getState: () => FormStoreState;
+    /** Shallow-merge a patch and synchronously notify every subscriber. */
+    setState: (patch: Partial<FormStoreState>) => void;
+    subscribe: (listener: FormStoreListener) => () => void;
+}
+export declare const createFormStore: (initialValues?: Record<string, unknown>) => FormStore;
+export declare function useStoreSelector<T>(store: FormStore, selector: (state: FormStoreState) => T, isEqual?: (a: T, b: T) => boolean): T;
+export declare const shallowEqualArrays: (a: readonly unknown[], b: readonly unknown[]) => boolean;
+export declare const shallowEqualObjects: (a: Record<string, unknown> | undefined, b: Record<string, unknown> | undefined) => boolean;
+/**
+ * Return a referentially-stable version of an (often inline-literal) props
+ * object: the previous reference is kept while the content stays
+ * shallow-equal, so downstream memo/context deps don't churn per render.
+ */
+export declare function useShallowStable<T extends object | undefined>(value: T): T;

package/es/components/ProForm/core/formStore.js

@@ -0,0 +1,101 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { useEffect, useReducer, useRef } from 'react';
+import useLatest from '@1money/hooks/useLatest';
+export var createFormStore = function createFormStore() {
+  var initialValues = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var state = {
+    values: initialValues,
+    errors: {},
+    warnings: {},
+    touched: {},
+    validating: {}
+  };
+  var listeners = new Set();
+  return {
+    getState: function getState() {
+      return state;
+    },
+    setState: function setState(patch) {
+      state = Object.assign(Object.assign({}, state), patch);
+      listeners.forEach(function (listener) {
+        return listener();
+      });
+    },
+    subscribe: function subscribe(listener) {
+      listeners.add(listener);
+      return function () {
+        listeners["delete"](listener);
+      };
+    }
+  };
+};
+// ---------------------------------------------------------------------------
+// useStoreSelector — subscribe to a selected slice of the store.
+//
+// The component re-renders ONLY when `isEqual(prevSelected, nextSelected)` is
+// false. The selector/equality/selected trio is re-captured in a ref on every
+// render, so inline selectors (closing over the latest props) are safe.
+// ---------------------------------------------------------------------------
+export function useStoreSelector(store, selector) {
+  var isEqual = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Object.is;
+  var _useReducer = useReducer(function (count) {
+      return count + 1;
+    }, 0),
+    _useReducer2 = _slicedToArray(_useReducer, 2),
+    forceRender = _useReducer2[1];
+  var selected = selector(store.getState());
+  var latestRef = useLatest({
+    selector: selector,
+    isEqual: isEqual,
+    selected: selected
+  });
+  useEffect(function () {
+    var checkForUpdates = function checkForUpdates() {
+      var latest = latestRef.current;
+      var next = latest.selector(store.getState());
+      if (!latest.isEqual(latest.selected, next)) {
+        forceRender();
+      }
+    };
+    // Catch commits that landed between render and subscription.
+    checkForUpdates();
+    return store.subscribe(checkForUpdates);
+  }, [store]);
+  return selected;
+}
+// ---------------------------------------------------------------------------
+// Equality helpers for multi-value selectors / props stabilization
+// ---------------------------------------------------------------------------
+export var shallowEqualArrays = function shallowEqualArrays(a, b) {
+  if (a === b) return true;
+  if (a.length !== b.length) return false;
+  for (var i = 0; i < a.length; i++) {
+    if (!Object.is(a[i], b[i])) return false;
+  }
+  return true;
+};
+export var shallowEqualObjects = function shallowEqualObjects(a, b) {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  var aKeys = Object.keys(a);
+  var bKeys = Object.keys(b);
+  if (aKeys.length !== bKeys.length) return false;
+  for (var _i = 0, _aKeys = aKeys; _i < _aKeys.length; _i++) {
+    var key = _aKeys[_i];
+    if (!Object.is(a[key], b[key])) return false;
+  }
+  return true;
+};
+/**
+ * Return a referentially-stable version of an (often inline-literal) props
+ * object: the previous reference is kept while the content stays
+ * shallow-equal, so downstream memo/context deps don't churn per render.
+ */
+export function useShallowStable(value) {
+  var ref = useRef(value);
+  if (!shallowEqualObjects(ref.current, value)) {
+    ref.current = value;
+  }
+  return ref.current;
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/ProForm/src/components/ProForm/core/formStore.ts","components/ProForm/core/formStore.js"],"names":["useEffect","useReducer","useRef","useLatest","createFormStore","initialValues","arguments","length","undefined","state","values","errors","warnings","touched","validating","listeners","Set","getState","setState","patch","Object","assign","forEach","listener","subscribe","add","useStoreSelector","store","selector","isEqual","is","_useReducer","count","_useReducer2","_slicedToArray","forceRender","selected","latestRef","checkForUpdates","latest","current","next","shallowEqualArrays","a","b","i","shallowEqualObjects","aKeys","keys","bKeys","_i","_aKeys","key","useShallowStable","value","ref"],"mappings":"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","file":"components/ProForm/core/formStore.js","sourcesContent":[null,"import { useEffect, useReducer, useRef } from 'react';\nimport useLatest from '@1money/hooks/useLatest';\nexport const createFormStore = (initialValues = {}) => {\n    let state = {\n        values: initialValues,\n        errors: {},\n        warnings: {},\n        touched: {},\n        validating: {},\n    };\n    const listeners = new Set();\n    return {\n        getState: () => state,\n        setState: (patch) => {\n            state = Object.assign(Object.assign({}, state), patch);\n            listeners.forEach((listener) => listener());\n        },\n        subscribe: (listener) => {\n            listeners.add(listener);\n            return () => {\n                listeners.delete(listener);\n            };\n        },\n    };\n};\n// ---------------------------------------------------------------------------\n// useStoreSelector — subscribe to a selected slice of the store.\n//\n// The component re-renders ONLY when `isEqual(prevSelected, nextSelected)` is\n// false. The selector/equality/selected trio is re-captured in a ref on every\n// render, so inline selectors (closing over the latest props) are safe.\n// ---------------------------------------------------------------------------\nexport function useStoreSelector(store, selector, isEqual = Object.is) {\n    const [, forceRender] = useReducer((count) => count + 1, 0);\n    const selected = selector(store.getState());\n    const latestRef = useLatest({ selector, isEqual, selected });\n    useEffect(() => {\n        const checkForUpdates = () => {\n            const latest = latestRef.current;\n            const next = latest.selector(store.getState());\n            if (!latest.isEqual(latest.selected, next)) {\n                forceRender();\n            }\n        };\n        // Catch commits that landed between render and subscription.\n        checkForUpdates();\n        return store.subscribe(checkForUpdates);\n    }, [store]);\n    return selected;\n}\n// ---------------------------------------------------------------------------\n// Equality helpers for multi-value selectors / props stabilization\n// ---------------------------------------------------------------------------\nexport const shallowEqualArrays = (a, b) => {\n    if (a === b)\n        return true;\n    if (a.length !== b.length)\n        return false;\n    for (let i = 0; i < a.length; i++) {\n        if (!Object.is(a[i], b[i]))\n            return false;\n    }\n    return true;\n};\nexport const shallowEqualObjects = (a, b) => {\n    if (a === b)\n        return true;\n    if (!a || !b)\n        return false;\n    const aKeys = Object.keys(a);\n    const bKeys = Object.keys(b);\n    if (aKeys.length !== bKeys.length)\n        return false;\n    for (const key of aKeys) {\n        if (!Object.is(a[key], b[key]))\n            return false;\n    }\n    return true;\n};\n/**\n * Return a referentially-stable version of an (often inline-literal) props\n * object: the previous reference is kept while the content stays\n * shallow-equal, so downstream memo/context deps don't churn per render.\n */\nexport function useShallowStable(value) {\n    const ref = useRef(value);\n    if (!shallowEqualObjects(ref.current, value)) {\n        ref.current = value;\n    }\n    return ref.current;\n}"],"sourceRoot":"../../../../../../../../../../src"}

package/es/components/ProForm/core/hooks/useForm.d.ts

@@ -1,3 +1,6 @@
+import type { FormStore } from '../formStore';
 import type { UseFormConfig, UseFormReturn } from '../interface';
-export declare const useForm: (config?: UseFormConfig) => UseFormReturn;
+export declare const useForm: (config?: UseFormConfig) => UseFormReturn & {
+    store: FormStore;
+};
 export default useForm;