@1money/component-ui 0.0.73 → 0.0.74

package/es/components/ProForm/hooks/useFieldRequest.js

@@ -27,7 +27,7 @@ var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, gene
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 };
-import { useEffect } from 'react';
+import { useEffect, useRef } from 'react';
 import useSafeState from '@1money/hooks/useSafeState';
 import useMemoizedFn from '@1money/hooks/useMemoizedFn';
 import useLatest from '@1money/hooks/useLatest';
@@ -35,6 +35,11 @@ import { stableSerialize } from '../utils';
 /**
  * Hook for async option fetching with param-based re-fetching.
  * Returns [loading, options].
+ *
+ * Race-safe: each fetch takes a sequence number
+ * and aborts the previous in-flight request — a stale response that resolves
+ * after a newer request never overwrites the newest options, and only the
+ * newest request controls `loading`.
  */
 export function useFieldRequest(request, params) {
   var _this = this;
@@ -48,10 +53,12 @@ export function useFieldRequest(request, params) {
     setOptions = _useSafeState4[1];
   // Always read the newest `request` without re-subscribing the effect below.
   var requestRef = useLatest(request);
+  var seqRef = useRef(0);
+  var abortRef = useRef(null);
   var serializedParams = stableSerialize(params);
   var fetchOptions = useMemoizedFn(function () {
     return __awaiter(_this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-      var fn, result;
+      var _a, fn, controller, seq, result, isAbort, _t;
       return _regeneratorRuntime.wrap(function (_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
@@ -62,31 +69,69 @@ export function useFieldRequest(request, params) {
             }
             return _context.abrupt("return");
           case 1:
+            (_a = abortRef.current) === null || _a === void 0 ? void 0 : _a.abort();
+            controller = new AbortController();
+            abortRef.current = controller;
+            seq = ++seqRef.current;
             setLoading(true);
             _context.prev = 2;
             _context.next = 3;
-            return fn(params);
+            return fn(params, controller.signal);
           case 3:
             result = _context.sent;
+            if (!(seq !== seqRef.current)) {
+              _context.next = 4;
+              break;
+            }
+            return _context.abrupt("return");
+          case 4:
+            // superseded — discard
             if (Array.isArray(result)) {
               setOptions(result);
             }
-          case 4:
-            _context.prev = 4;
-            setLoading(false);
-            return _context.finish(4);
+            _context.next = 6;
+            break;
           case 5:
+            _context.prev = 5;
+            _t = _context["catch"](2);
+            // Superseded requests (our own aborts always land here via the seq
+            // mismatch) are swallowed. For the LATEST request, an AbortError can
+            // only come from a CONSUMER-side abort (e.g. AbortSignal.timeout) —
+            // also swallowed, mirroring fetch-cancellation conventions; genuine
+            // failures propagate.
+            isAbort = _t instanceof Error && _t.name === 'AbortError';
+            if (!(seq === seqRef.current && !isAbort)) {
+              _context.next = 6;
+              break;
+            }
+            throw _t;
+          case 6:
+            _context.prev = 6;
+            if (seq === seqRef.current) {
+              setLoading(false);
+            }
+            return _context.finish(6);
+          case 7:
           case "end":
             return _context.stop();
         }
-      }, _callee, null, [[2,, 4, 5]]);
+      }, _callee, null, [[2, 5, 6, 7]]);
     }));
   });
   useEffect(function () {
     if (!requestRef.current) return;
     fetchOptions();
   }, [serializedParams]);
+  // Honor the cancellation contract on unmount: abort the in-flight request
+  // and bump the sequence so any late settle (result or error) is discarded.
+  useEffect(function () {
+    return function () {
+      var _a;
+      seqRef.current += 1;
+      (_a = abortRef.current) === null || _a === void 0 ? void 0 : _a.abort();
+    };
+  }, []);
   return [loading, options];
 }
 export default useFieldRequest;
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/ProForm/hooks/useFieldRequest.js","components/ProForm/src/components/ProForm/hooks/useFieldRequest.ts"],"names":["__awaiter","thisArg","_arguments","P","generator","adopt","value","resolve","Promise","reject","fulfilled","step","next","e","rejected","result","done","then","apply","useEffect","useRef","useSafeState","useMemoizedFn","useLatest","stableSerialize","useFieldRequest","request","params","_this","_useSafeState","_useSafeState2","_slicedToArray","loading","setLoading","_useSafeState3","_useSafeState4","options","setOptions","requestRef","seqRef","abortRef","serializedParams","fetchOptions","_regeneratorRuntime","mark","_callee","_a","fn","controller","seq","isAbort","_t","wrap","_context","prev","current","abrupt","abort","AbortController","signal","sent","Array","isArray","Error","name","finish","stop"],"mappings":"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","file":"components/ProForm/hooks/useFieldRequest.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 { useEffect, useRef } from 'react';\nimport useSafeState from '@1money/hooks/useSafeState';\nimport useMemoizedFn from '@1money/hooks/useMemoizedFn';\nimport useLatest from '@1money/hooks/useLatest';\nimport { stableSerialize } from '../utils';\n/**\n * Hook for async option fetching with param-based re-fetching.\n * Returns [loading, options].\n *\n * Race-safe: each fetch takes a sequence number\n * and aborts the previous in-flight request — a stale response that resolves\n * after a newer request never overwrites the newest options, and only the\n * newest request controls `loading`.\n */\nexport function useFieldRequest(request, params) {\n    const [loading, setLoading] = useSafeState(false);\n    const [options, setOptions] = useSafeState([]);\n    // Always read the newest `request` without re-subscribing the effect below.\n    const requestRef = useLatest(request);\n    const seqRef = useRef(0);\n    const abortRef = useRef(null);\n    const serializedParams = stableSerialize(params);\n    const fetchOptions = useMemoizedFn(() => __awaiter(this, void 0, void 0, function* () {\n        var _a;\n        const fn = requestRef.current;\n        if (!fn)\n            return;\n        (_a = abortRef.current) === null || _a === void 0 ? void 0 : _a.abort();\n        const controller = new AbortController();\n        abortRef.current = controller;\n        const seq = ++seqRef.current;\n        setLoading(true);\n        try {\n            const result = yield fn(params, controller.signal);\n            if (seq !== seqRef.current)\n                return; // superseded — discard\n            if (Array.isArray(result)) {\n                setOptions(result);\n            }\n        }\n        catch (error) {\n            // Superseded requests (our own aborts always land here via the seq\n            // mismatch) are swallowed. For the LATEST request, an AbortError can\n            // only come from a CONSUMER-side abort (e.g. AbortSignal.timeout) —\n            // also swallowed, mirroring fetch-cancellation conventions; genuine\n            // failures propagate.\n            const isAbort = error instanceof Error && error.name === 'AbortError';\n            if (seq === seqRef.current && !isAbort) {\n                throw error;\n            }\n        }\n        finally {\n            if (seq === seqRef.current) {\n                setLoading(false);\n            }\n        }\n    }));\n    useEffect(() => {\n        if (!requestRef.current)\n            return;\n        fetchOptions();\n    }, [serializedParams]);\n    // Honor the cancellation contract on unmount: abort the in-flight request\n    // and bump the sequence so any late settle (result or error) is discarded.\n    useEffect(() => {\n        return () => {\n            var _a;\n            seqRef.current += 1;\n            (_a = abortRef.current) === null || _a === void 0 ? void 0 : _a.abort();\n        };\n    }, []);\n    return [loading, options];\n}\nexport default useFieldRequest;",null],"sourceRoot":"../../../../../../../../../../src"}

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

@@ -0,0 +1,16 @@
+export type ProFormSyncToUrl = boolean | ((values: Record<string, unknown>, type: 'get' | 'set') => Record<string, unknown>);
+export interface UseUrlSyncOptions {
+    syncToUrl?: ProFormSyncToUrl;
+    /** Extra params always written to the URL alongside the form values. */
+    extraUrlParams?: Record<string, unknown>;
+}
+export interface UseUrlSyncResult {
+    /** URL params captured at mount (after the `'get'` mapping) — merge into initialValues. */
+    urlInitialValues: Record<string, unknown>;
+    /** Write submitted values (+ extraUrlParams) into the URL. */
+    onUrlSyncFinish: (finalValues: Record<string, unknown>) => void;
+    /** Clear this form's own params; foreign params and extraUrlParams survive. */
+    onUrlSyncReset: () => void;
+}
+export declare function useUrlSync({ syncToUrl, extraUrlParams }: UseUrlSyncOptions): UseUrlSyncResult;
+export default useUrlSync;

package/es/components/ProForm/hooks/useUrlSync.js

@@ -0,0 +1,170 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { useEffect, useRef } from 'react';
+import useMemoizedFn from '@1money/hooks/useMemoizedFn';
+import { stableSerialize } from '../utils';
+function getUrlParams() {
+  if (typeof window === 'undefined') return {};
+  var params = {};
+  new URLSearchParams(window.location.search).forEach(function (v, k) {
+    params[k] = v;
+  });
+  return params;
+}
+/**
+ * Write the given values into the URL while PRESERVING unrelated query params.
+ * Only keys in `managedKeys` are cleared before writing. Returns the new set
+ * of managed keys.
+ */
+function setUrlParams(params, managedKeys) {
+  if (typeof window === 'undefined') return new Set(managedKeys);
+  var sp = new URLSearchParams(window.location.search);
+  managedKeys.forEach(function (k) {
+    return sp["delete"](k);
+  });
+  var written = new Set();
+  for (var _i = 0, _Object$entries = Object.entries(params); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+      k = _Object$entries$_i[0],
+      v = _Object$entries$_i[1];
+    if (v !== null && v !== undefined && v !== '') {
+      sp.set(k, String(v));
+      written.add(k);
+    }
+  }
+  var search = sp.toString();
+  // PRESERVE the hash — hash routers keep their whole route there; dropping
+  // it would navigate the SPA away on every write.
+  var url = (search ? "".concat(window.location.pathname, "?").concat(search) : window.location.pathname) + window.location.hash;
+  // Skip the history call when nothing changes — Safari throttles the
+  // history API, so identical rewrites are wasted budget.
+  var currentUrl = "".concat(window.location.pathname).concat(window.location.search).concat(window.location.hash);
+  if (url !== currentUrl) {
+    window.history.replaceState(null, '', url);
+  }
+  return written;
+}
+export function useUrlSync(_ref) {
+  var syncToUrl = _ref.syncToUrl,
+    extraUrlParams = _ref.extraUrlParams;
+  // One-time mount snapshot. Lazy ref init is IDEMPOTENT, so it is safe under
+  // StrictMode's double render (an impure "first run" flag inside useMemo
+  // would return the unmerged value on the replay invocation).
+  var urlParamsAtMountRef = useRef(null);
+  if (urlParamsAtMountRef.current === null) {
+    urlParamsAtMountRef.current = syncToUrl ? getUrlParams() : {};
+  }
+  // The route this form mounted on. All deferred URL writes are guarded by
+  // it: an onFinish that NAVIGATES must not get the old form's params
+  // stamped onto the new route's URL. The pathname check covers path
+  // routers; the activeRef covers any navigation that UNMOUNTS the form
+  // (including hash routers, where the pathname never changes).
+  var mountPathnameRef = useRef(typeof window === 'undefined' ? '' : window.location.pathname);
+  var activeRef = useRef(true);
+  useEffect(function () {
+    activeRef.current = true;
+    return function () {
+      activeRef.current = false;
+    };
+  }, []);
+  var isWritable = function isWritable() {
+    return activeRef.current && typeof window !== 'undefined' && window.location.pathname === mountPathnameRef.current;
+  };
+  // Keys this form has WRITTEN to the URL — the only keys submit/reset may clear.
+  var managedKeysRef = useRef(new Set());
+  // Boolean-mode only: URL params merged into initialValues but NOT yet
+  // claimed (they may belong to someone else, e.g. `?tab=…`).
+  var urlSeededRef = useRef({});
+  var urlInitialValuesRef = useRef(null);
+  if (urlInitialValuesRef.current === null) {
+    if (!syncToUrl) {
+      urlInitialValuesRef.current = {};
+    } else if (typeof syncToUrl === 'function') {
+      var fromUrl = syncToUrl(urlParamsAtMountRef.current, 'get');
+      // Idempotent ref writes — same input on every invocation.
+      managedKeysRef.current = new Set(Object.keys(fromUrl));
+      urlInitialValuesRef.current = fromUrl;
+    } else {
+      urlSeededRef.current = Object.assign({}, urlParamsAtMountRef.current);
+      urlInitialValuesRef.current = Object.assign({}, urlParamsAtMountRef.current);
+    }
+  }
+  var writeValues = useMemoizedFn(function (values) {
+    if (!syncToUrl || !isWritable()) return;
+    var toWrite;
+    var toClear = new Set(managedKeysRef.current);
+    if (typeof syncToUrl === 'function') {
+      // extraUrlParams bypass the consumer's mapper ("always written"): they
+      // form the base and the mapper's output wins on key collisions.
+      toWrite = Object.assign(Object.assign({}, extraUrlParams), syncToUrl(values, 'set'));
+    } else {
+      // Skip URL-seeded keys we never wrote whose value is unchanged — they
+      // may belong to someone else; leave them in the URL untouched. A seeded
+      // key whose value DID change is claimed from now on.
+      toWrite = {};
+      for (var _i2 = 0, _Object$entries2 = Object.entries(values); _i2 < _Object$entries2.length; _i2++) {
+        var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
+          key = _Object$entries2$_i[0],
+          value = _Object$entries2$_i[1];
+        var seeded = urlSeededRef.current[key];
+        if (seeded !== undefined && !managedKeysRef.current.has(key) && String(value) === seeded) {
+          continue;
+        }
+        delete urlSeededRef.current[key];
+        toClear.add(key);
+        toWrite[key] = value;
+      }
+      // Seeded keys missing from the submitted values were cleared by the
+      // user (omitNil strips empty values) — claim them and remove their
+      // stale params from the URL.
+      for (var _i3 = 0, _Object$keys = Object.keys(urlSeededRef.current); _i3 < _Object$keys.length; _i3++) {
+        var _key = _Object$keys[_i3];
+        if (!(_key in values)) {
+          delete urlSeededRef.current[_key];
+          toClear.add(_key);
+        }
+      }
+    }
+    managedKeysRef.current = setUrlParams(toWrite, toClear);
+  });
+  var onUrlSyncFinish = useMemoizedFn(function (finalValues) {
+    if (!syncToUrl) return;
+    // extraUrlParams are applied exactly once per branch: pre-merged here for
+    // the boolean form (values win on collision); the function form applies
+    // them AFTER the consumer's mapper inside writeValues, so the mapper
+    // never sees foreign keys in its input.
+    var shouldPreMerge = typeof syncToUrl !== 'function' && extraUrlParams;
+    writeValues(shouldPreMerge ? Object.assign(Object.assign({}, extraUrlParams), finalValues) : finalValues);
+  });
+  var onUrlSyncReset = useMemoizedFn(function () {
+    if (!syncToUrl || !isWritable()) return;
+    // Clear every managed key, then re-write extraUrlParams (they persist).
+    managedKeysRef.current = setUrlParams(Object.assign({}, extraUrlParams), managedKeysRef.current);
+  });
+  // Keep extraUrlParams in the URL as they change (value-compared). The
+  // previously-written extra keys are tracked so a key REMOVED from
+  // extraUrlParams is also removed from the URL — not just overwritten.
+  var extraKeysRef = useRef(new Set());
+  var serializedExtra = syncToUrl ? stableSerialize(extraUrlParams) : '';
+  useEffect(function () {
+    if (!syncToUrl || !isWritable()) return;
+    var next = extraUrlParams !== null && extraUrlParams !== void 0 ? extraUrlParams : {};
+    if (extraKeysRef.current.size === 0 && Object.keys(next).length === 0) return;
+    var written = setUrlParams(Object.assign({}, next), extraKeysRef.current);
+    var merged = new Set(managedKeysRef.current);
+    extraKeysRef.current.forEach(function (key) {
+      if (!written.has(key)) merged["delete"](key);
+    });
+    written.forEach(function (key) {
+      return merged.add(key);
+    });
+    managedKeysRef.current = merged;
+    extraKeysRef.current = written;
+  }, [serializedExtra]);
+  return {
+    urlInitialValues: urlInitialValuesRef.current,
+    onUrlSyncFinish: onUrlSyncFinish,
+    onUrlSyncReset: onUrlSyncReset
+  };
+}
+export default useUrlSync;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/ProForm/src/components/ProForm/hooks/useUrlSync.ts","components/ProForm/hooks/useUrlSync.js"],"names":["useEffect","useRef","useMemoizedFn","stableSerialize","getUrlParams","window","params","URLSearchParams","location","search","forEach","v","k","setUrlParams","managedKeys","Set","sp","written","_i","_Object$entries","Object","entries","length","_Object$entries$_i","_slicedToArray","undefined","set","String","add","toString","url","concat","pathname","hash","currentUrl","history","replaceState","useUrlSync","_ref","syncToUrl","extraUrlParams","urlParamsAtMountRef","current","mountPathnameRef","activeRef","isWritable","managedKeysRef","urlSeededRef","urlInitialValuesRef","fromUrl","keys","assign","writeValues","values","toWrite","toClear","_i2","_Object$entries2","_Object$entries2$_i","key","value","seeded","has","_i3","_Object$keys","onUrlSyncFinish","finalValues","shouldPreMerge","onUrlSyncReset","extraKeysRef","serializedExtra","next","size","merged","urlInitialValues"],"mappings":"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","file":"components/ProForm/hooks/useUrlSync.js","sourcesContent":[null,"import { useEffect, useRef } from 'react';\nimport useMemoizedFn from '@1money/hooks/useMemoizedFn';\nimport { stableSerialize } from '../utils';\nfunction getUrlParams() {\n    if (typeof window === 'undefined')\n        return {};\n    const params = {};\n    new URLSearchParams(window.location.search).forEach((v, k) => {\n        params[k] = v;\n    });\n    return params;\n}\n/**\n * Write the given values into the URL while PRESERVING unrelated query params.\n * Only keys in `managedKeys` are cleared before writing. Returns the new set\n * of managed keys.\n */\nfunction setUrlParams(params, managedKeys) {\n    if (typeof window === 'undefined')\n        return new Set(managedKeys);\n    const sp = new URLSearchParams(window.location.search);\n    managedKeys.forEach((k) => sp.delete(k));\n    const written = new Set();\n    for (const [k, v] of Object.entries(params)) {\n        if (v !== null && v !== undefined && v !== '') {\n            sp.set(k, String(v));\n            written.add(k);\n        }\n    }\n    const search = sp.toString();\n    // PRESERVE the hash — hash routers keep their whole route there; dropping\n    // it would navigate the SPA away on every write.\n    const url = (search ? `${window.location.pathname}?${search}` : window.location.pathname) +\n        window.location.hash;\n    // Skip the history call when nothing changes — Safari throttles the\n    // history API, so identical rewrites are wasted budget.\n    const currentUrl = `${window.location.pathname}${window.location.search}${window.location.hash}`;\n    if (url !== currentUrl) {\n        window.history.replaceState(null, '', url);\n    }\n    return written;\n}\nexport function useUrlSync({ syncToUrl, extraUrlParams }) {\n    // One-time mount snapshot. Lazy ref init is IDEMPOTENT, so it is safe under\n    // StrictMode's double render (an impure \"first run\" flag inside useMemo\n    // would return the unmerged value on the replay invocation).\n    const urlParamsAtMountRef = useRef(null);\n    if (urlParamsAtMountRef.current === null) {\n        urlParamsAtMountRef.current = syncToUrl ? getUrlParams() : {};\n    }\n    // The route this form mounted on. All deferred URL writes are guarded by\n    // it: an onFinish that NAVIGATES must not get the old form's params\n    // stamped onto the new route's URL. The pathname check covers path\n    // routers; the activeRef covers any navigation that UNMOUNTS the form\n    // (including hash routers, where the pathname never changes).\n    const mountPathnameRef = useRef(typeof window === 'undefined' ? '' : window.location.pathname);\n    const activeRef = useRef(true);\n    useEffect(() => {\n        activeRef.current = true;\n        return () => {\n            activeRef.current = false;\n        };\n    }, []);\n    const isWritable = () => activeRef.current &&\n        typeof window !== 'undefined' &&\n        window.location.pathname === mountPathnameRef.current;\n    // Keys this form has WRITTEN to the URL — the only keys submit/reset may clear.\n    const managedKeysRef = useRef(new Set());\n    // Boolean-mode only: URL params merged into initialValues but NOT yet\n    // claimed (they may belong to someone else, e.g. `?tab=…`).\n    const urlSeededRef = useRef({});\n    const urlInitialValuesRef = useRef(null);\n    if (urlInitialValuesRef.current === null) {\n        if (!syncToUrl) {\n            urlInitialValuesRef.current = {};\n        }\n        else if (typeof syncToUrl === 'function') {\n            const fromUrl = syncToUrl(urlParamsAtMountRef.current, 'get');\n            // Idempotent ref writes — same input on every invocation.\n            managedKeysRef.current = new Set(Object.keys(fromUrl));\n            urlInitialValuesRef.current = fromUrl;\n        }\n        else {\n            urlSeededRef.current = Object.assign({}, urlParamsAtMountRef.current);\n            urlInitialValuesRef.current = Object.assign({}, urlParamsAtMountRef.current);\n        }\n    }\n    const writeValues = useMemoizedFn((values) => {\n        if (!syncToUrl || !isWritable())\n            return;\n        let toWrite;\n        const toClear = new Set(managedKeysRef.current);\n        if (typeof syncToUrl === 'function') {\n            // extraUrlParams bypass the consumer's mapper (\"always written\"): they\n            // form the base and the mapper's output wins on key collisions.\n            toWrite = Object.assign(Object.assign({}, extraUrlParams), syncToUrl(values, 'set'));\n        }\n        else {\n            // Skip URL-seeded keys we never wrote whose value is unchanged — they\n            // may belong to someone else; leave them in the URL untouched. A seeded\n            // key whose value DID change is claimed from now on.\n            toWrite = {};\n            for (const [key, value] of Object.entries(values)) {\n                const seeded = urlSeededRef.current[key];\n                if (seeded !== undefined &&\n                    !managedKeysRef.current.has(key) &&\n                    String(value) === seeded) {\n                    continue;\n                }\n                delete urlSeededRef.current[key];\n                toClear.add(key);\n                toWrite[key] = value;\n            }\n            // Seeded keys missing from the submitted values were cleared by the\n            // user (omitNil strips empty values) — claim them and remove their\n            // stale params from the URL.\n            for (const key of Object.keys(urlSeededRef.current)) {\n                if (!(key in values)) {\n                    delete urlSeededRef.current[key];\n                    toClear.add(key);\n                }\n            }\n        }\n        managedKeysRef.current = setUrlParams(toWrite, toClear);\n    });\n    const onUrlSyncFinish = useMemoizedFn((finalValues) => {\n        if (!syncToUrl)\n            return;\n        // extraUrlParams are applied exactly once per branch: pre-merged here for\n        // the boolean form (values win on collision); the function form applies\n        // them AFTER the consumer's mapper inside writeValues, so the mapper\n        // never sees foreign keys in its input.\n        const shouldPreMerge = typeof syncToUrl !== 'function' && extraUrlParams;\n        writeValues(shouldPreMerge ? Object.assign(Object.assign({}, extraUrlParams), finalValues) : finalValues);\n    });\n    const onUrlSyncReset = useMemoizedFn(() => {\n        if (!syncToUrl || !isWritable())\n            return;\n        // Clear every managed key, then re-write extraUrlParams (they persist).\n        managedKeysRef.current = setUrlParams(Object.assign({}, extraUrlParams), managedKeysRef.current);\n    });\n    // Keep extraUrlParams in the URL as they change (value-compared). The\n    // previously-written extra keys are tracked so a key REMOVED from\n    // extraUrlParams is also removed from the URL — not just overwritten.\n    const extraKeysRef = useRef(new Set());\n    const serializedExtra = syncToUrl ? stableSerialize(extraUrlParams) : '';\n    useEffect(() => {\n        if (!syncToUrl || !isWritable())\n            return;\n        const next = extraUrlParams !== null && extraUrlParams !== void 0 ? extraUrlParams : {};\n        if (extraKeysRef.current.size === 0 && Object.keys(next).length === 0)\n            return;\n        const written = setUrlParams(Object.assign({}, next), extraKeysRef.current);\n        const merged = new Set(managedKeysRef.current);\n        extraKeysRef.current.forEach((key) => {\n            if (!written.has(key))\n                merged.delete(key);\n        });\n        written.forEach((key) => merged.add(key));\n        managedKeysRef.current = merged;\n        extraKeysRef.current = written;\n    }, [serializedExtra]);\n    return {\n        urlInitialValues: urlInitialValuesRef.current,\n        onUrlSyncFinish,\n        onUrlSyncReset,\n    };\n}\nexport default useUrlSync;"],"sourceRoot":"../../../../../../../../../../src"}

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

@@ -7,7 +7,7 @@ declare const ProForm: import("./ProForm").ProFormComponent & {
     useInstance: <Values = Record<string, unknown>>() => import("./interface").ProFormFormInstance<Values>;
     useContext: () => import("./interface").ProFormContextValue;
     useWatch: import("./context").UseFormWatch;
-    Dependency: import("react").NamedExoticComponent<import("./interface").ProFormDependencyProps>;
+    Dependency: import("./ProFormDependency").ProFormDependencyComponent;
     List: import("react").NamedExoticComponent<import("./interface").ProFormListProps>;
     Group: import("react").NamedExoticComponent<import("./interface").ProFormGroupProps>;
     FieldSet: import("react").NamedExoticComponent<import("./interface").ProFormFieldSetProps>;
@@ -39,7 +39,7 @@ export { DialogForm } from './layouts/DialogForm';
 export { QueryFilter } from './layouts/QueryFilter';
 export { useFormWatch } from './context';
 export type { UseFormWatch } from './context';
-export type { ProFormProps, ProFormItemProps, ProFormItemSharedProps, ProFormFieldProps, ProFormContextValue, ProFormStableContextValue, ProFormStateContextValue, ProFormFormInstance, ProFormFieldTransformFn, ProFormFieldConvertValueFn, ProFormDateFormatter, ProFormValueEnumObj, ProFormRequestOption, ProFormValueType, FormListContextValue, ProFormColProps, ProFormFieldSetProps, ProFormGroupProps, SubmitterProps, ProFormDependencyProps, ProFormListProps, ProFormListAction, DrawerFormProps, DialogFormProps, QueryFilterProps, CreateProFormFieldConfig, ProFormSchemaColumn, ProFormSchemaValueType, SchemaFormProps, } from './interface';
+export type { ProFormSyncToUrl, ProFormProps, ProFormItemProps, ProFormItemSharedProps, ProFormLayoutConfig, ProFormFieldProps, ProFormContextValue, ProFormStableContextValue, ProFormStateContextValue, ProFormFormInstance, ProFormValidateResult, ProFormFieldName, ProFormFieldTransformFn, ProFormFieldConvertValueFn, ProFormDateFormatter, ProFormValueEnumObj, ProFormRequestOption, ProFormValueType, FormListContextValue, ProFormColProps, ProFormFieldSetProps, ProFormGroupProps, SubmitterProps, ProFormDependencyProps, ProFormListProps, ProFormListAction, DrawerFormProps, DialogFormProps, QueryFilterProps, CreateProFormFieldConfig, ProFormSchemaColumn, ProFormSchemaValueType, SchemaFormProps, } from './interface';
 export { CSS_PREFIX, WIDTH_SIZE_MAP, DEFAULT_COL_SPAN, DEFAULT_TEXT, PROFORM_MODES } from './constants';
 export type { ProFormMode } from './constants';
 export type { FormInstance, FormCoreInstance, Rule, ValidateTrigger, ValidateStatus, FormLayout, FormSize, LabelAlign, UseFormConfig, UseFormReturn, UseFormInternals, } from './core/interface';

package/es/components/ProForm/index.js

@@ -57,4 +57,4 @@ export { DialogForm } from './layouts/DialogForm';
 export { QueryFilter } from './layouts/QueryFilter';
 export { useFormWatch } from './context';
 export { CSS_PREFIX, WIDTH_SIZE_MAP, DEFAULT_COL_SPAN, DEFAULT_TEXT, PROFORM_MODES } from './constants';
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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