@payloadcms/ui 3.81.0-internal-debug.1a0f4d0 → 3.81.0

package/dist/forms/Form/mergeServerFormState.js

@@ -1,14 +1,7 @@
 'use client';
-import { dequal } from 'dequal/lite';
-// lite: no need for Map and Set support
+
+import { dequal } from 'dequal/lite'; // lite: no need for Map and Set support
 /**
- * If true, will accept all values from the server, overriding any current values in local state.
- * Can also provide an options object for more granular control.
- */ /**
-       * When `false`, will accept the values from the server _UNLESS_ the value has been modified locally since the request was made.
-       * This is useful for autosave, for example, where hooks may have modified the field's value on the server while you were still making changes.
-       * @default undefined
-       */ /**
  * Parses an array field path to extract the array path, row index, and field path.
  * Handles nested arrays by finding the deepest numeric index.
  *
@@ -22,25 +15,26 @@ import { dequal } from 'dequal/lite';
  * @example
  * parseArrayFieldPath('blocks.0.items.1.title')
  * // Returns: { arrayPath: 'blocks.0.items', rowIndex: 1, fieldPath: 'title' }
- */ function parseArrayFieldPath(path) {
-    const segments = path.split('.');
-    // Find the last numeric index (indicates array row)
-    let lastNumericIndex = -1;
-    for(let i = segments.length - 1; i >= 0; i--){
-        if (/^\d+$/.test(segments[i])) {
-            lastNumericIndex = i;
-            break;
-        }
-    }
-    // Not an array field if no numeric index or nothing after it
-    if (lastNumericIndex === -1 || lastNumericIndex === segments.length - 1) {
-        return null;
+ */
+function parseArrayFieldPath(path) {
+  const segments = path.split('.');
+  // Find the last numeric index (indicates array row)
+  let lastNumericIndex = -1;
+  for (let i = segments.length - 1; i >= 0; i--) {
+    if (/^\d+$/.test(segments[i])) {
+      lastNumericIndex = i;
+      break;
     }
-    return {
-        arrayPath: segments.slice(0, lastNumericIndex).join('.'),
-        fieldPath: segments.slice(lastNumericIndex + 1).join('.'),
-        rowIndex: parseInt(segments[lastNumericIndex], 10)
-    };
+  }
+  // Not an array field if no numeric index or nothing after it
+  if (lastNumericIndex === -1 || lastNumericIndex === segments.length - 1) {
+    return null;
+  }
+  return {
+    arrayPath: segments.slice(0, lastNumericIndex).join('.'),
+    fieldPath: segments.slice(lastNumericIndex + 1).join('.'),
+    rowIndex: parseInt(segments[lastNumericIndex], 10)
+  };
 }
 /**
  * This function receives form state from the server and intelligently merges it into the client state.
@@ -53,129 +47,145 @@ import { dequal } from 'dequal/lite';
  *
  * This function applies some defaults, as well as cleans up the server response in preparation for the client.
  * e.g. it will set `valid` and `passesCondition` to true if undefined, and remove `addedByServer` from the response.
- */ export const mergeServerFormState = ({ acceptValues, currentState = {}, incomingState })=>{
-    const newState = {
-        ...currentState
-    };
-    for (const [path, incomingField] of Object.entries(incomingState || {})){
-        if (!(path in currentState) && !incomingField.addedByServer) {
-            continue;
-        }
-        /**
-     * If it's a new field added by the server, always accept the value.
-     * Otherwise:
-     *   a. accept all values when explicitly requested, e.g. on submit
-     *   b. only accept values for unmodified fields, e.g. on autosave
-     */ let shouldAcceptValue = incomingField.addedByServer || acceptValues === true || typeof acceptValues === 'object' && acceptValues !== null && // Note: Must be explicitly `false`, allow `null` or `undefined` to mean true
-        acceptValues.overrideLocalChanges === false && !currentState[path]?.isModified;
-        /**
-     * For array row fields, verify the row IDs match at the given index before accepting
-     * server values. If rows were reordered or deleted while the request was in-flight,
-     * the same index may refer to different rows, and accepting the server value would
-     * overwrite the wrong row's data.
-     *
-     * This guard only applies during autosave. On explicit save (acceptValues === true),
-     * the server response is authoritative and this check is bypassed.
-     */ if (shouldAcceptValue && !incomingField.addedByServer && acceptValues !== true) {
-            const parsed = parseArrayFieldPath(path);
-            if (parsed) {
-                const { arrayPath, rowIndex } = parsed;
-                const clientRowId = currentState[arrayPath]?.rows?.[rowIndex]?.id;
-                const serverRowId = incomingState[arrayPath]?.rows?.[rowIndex]?.id;
-                if (clientRowId === undefined || serverRowId && clientRowId !== serverRowId) {
-                    shouldAcceptValue = false;
-                }
-            }
+ */
+export const mergeServerFormState = ({
+  acceptValues,
+  currentState = {},
+  incomingState
+}) => {
+  const newState = {
+    ...currentState
+  };
+  for (const [path, incomingField] of Object.entries(incomingState || {})) {
+    if (!(path in currentState) && !incomingField.addedByServer) {
+      continue;
+    }
+    /**
+    * If it's a new field added by the server, always accept the value.
+    * Otherwise:
+    *   a. accept all values when explicitly requested, e.g. on submit
+    *   b. only accept values for unmodified fields, e.g. on autosave
+    */
+    let shouldAcceptValue = incomingField.addedByServer || acceptValues === true || typeof acceptValues === 'object' && acceptValues !== null &&
+    // Note: Must be explicitly `false`, allow `null` or `undefined` to mean true
+    acceptValues.overrideLocalChanges === false && !currentState[path]?.isModified;
+    /**
+    * For array row fields, verify the row IDs match at the given index before accepting
+    * server values. If rows were reordered or deleted while the request was in-flight,
+    * the same index may refer to different rows, and accepting the server value would
+    * overwrite the wrong row's data.
+    *
+    * This guard only applies during autosave. On explicit save (acceptValues === true),
+    * the server response is authoritative and this check is bypassed.
+    */
+    if (shouldAcceptValue && !incomingField.addedByServer && acceptValues !== true) {
+      const parsed = parseArrayFieldPath(path);
+      if (parsed) {
+        const {
+          arrayPath,
+          rowIndex
+        } = parsed;
+        const clientRowId = currentState[arrayPath]?.rows?.[rowIndex]?.id;
+        const serverRowId = incomingState[arrayPath]?.rows?.[rowIndex]?.id;
+        if (clientRowId === undefined || serverRowId && clientRowId !== serverRowId) {
+          shouldAcceptValue = false;
         }
-        let sanitizedIncomingField = incomingField;
-        if (!shouldAcceptValue) {
+      }
+    }
+    let sanitizedIncomingField = incomingField;
+    if (!shouldAcceptValue) {
+      /**
+      * Note: do not delete properties off `incomingField` as this will mutate the original object
+      * Instead, omit them from the destructured object by excluding specific keys
+      * This will also ensure we don't set `undefined` into the result unnecessarily
+      */
+      const {
+        initialValue,
+        value,
+        ...rest
+      } = incomingField;
+      sanitizedIncomingField = rest;
+    }
+    newState[path] = {
+      ...currentState[path],
+      ...sanitizedIncomingField
+    };
+    if (currentState[path] && 'errorPaths' in currentState[path] && !('errorPaths' in incomingField)) {
+      newState[path].errorPaths = [];
+    }
+    /**
+    * Deeply merge the rows array to ensure changes to local state are not lost while the request was pending
+    * For example, the server response could come back with a row which has been deleted on the client
+    * Loop over the incoming rows, if it exists in client side form state, merge in any new properties from the server
+    * Note: read `currentState` and not `newState` here, as the `rows` property have already been merged above
+    *
+    * On explicit save (acceptValues === true), the server is authoritative - accept server row order.
+    * On autosave (acceptValues !== true), the client is source of truth - use ID-based matching.
+    */
+    if (Array.isArray(incomingField.rows) && path in currentState) {
+      if (acceptValues === true) {
+        // Explicit save: server is authoritative, use index-based merging
+        newState[path].rows = incomingField.rows.map((serverRow, index) => ({
+          ...(currentState[path]?.rows?.[index] || {}),
+          ...serverRow
+        }));
+      } else {
+        // Autosave: client is source of truth, use ID-based matching
+        newState[path].rows = [...(currentState[path]?.rows || [])]; // shallow copy to avoid mutating the original array
+        incomingField.rows.forEach(row => {
+          const indexInCurrentState = currentState[path].rows?.findIndex(existingRow => existingRow.id === row.id);
+          if (indexInCurrentState > -1) {
+            newState[path].rows[indexInCurrentState] = {
+              ...currentState[path].rows[indexInCurrentState],
+              ...row
+            };
+          } else if (row.addedByServer) {
             /**
-       * Note: do not delete properties off `incomingField` as this will mutate the original object
-       * Instead, omit them from the destructured object by excluding specific keys
-       * This will also ensure we don't set `undefined` into the result unnecessarily
-       */ const { initialValue, value, ...rest } = incomingField;
-            sanitizedIncomingField = rest;
-        }
-        newState[path] = {
-            ...currentState[path],
-            ...sanitizedIncomingField
-        };
-        if (currentState[path] && 'errorPaths' in currentState[path] && !('errorPaths' in incomingField)) {
-            newState[path].errorPaths = [];
-        }
+            * Note: This is a known limitation of computed array and block rows
+            * If a new row was added by the server, we append it to the _end_ of this array
+            * This is because the client is the source of truth, and it has arrays ordered in a certain position
+            * For example, the user may have re-ordered rows client-side while a long running request is processing
+            * This means that we _cannot_ slice a new row into the second position on the server, for example
+            * By the time it gets back to the client, its index is stale
+            */
+            const newRow = {
+              ...row
+            };
+            delete newRow.addedByServer;
+            newState[path].rows.push(newRow);
+          }
+        });
         /**
-     * Deeply merge the rows array to ensure changes to local state are not lost while the request was pending
-     * For example, the server response could come back with a row which has been deleted on the client
-     * Loop over the incoming rows, if it exists in client side form state, merge in any new properties from the server
-     * Note: read `currentState` and not `newState` here, as the `rows` property have already been merged above
-     *
-     * On explicit save (acceptValues === true), the server is authoritative - accept server row order.
-     * On autosave (acceptValues !== true), the client is source of truth - use ID-based matching.
-     */ if (Array.isArray(incomingField.rows) && path in currentState) {
-            if (acceptValues === true) {
-                // Explicit save: server is authoritative, use index-based merging
-                newState[path].rows = incomingField.rows.map((serverRow, index)=>({
-                        ...currentState[path]?.rows?.[index] || {},
-                        ...serverRow
-                    }));
-            } else {
-                // Autosave: client is source of truth, use ID-based matching
-                newState[path].rows = [
-                    ...currentState[path]?.rows || []
-                ];
-                // shallow copy to avoid mutating the original array
-                incomingField.rows.forEach((row)=>{
-                    const indexInCurrentState = currentState[path].rows?.findIndex((existingRow)=>existingRow.id === row.id);
-                    if (indexInCurrentState > -1) {
-                        newState[path].rows[indexInCurrentState] = {
-                            ...currentState[path].rows[indexInCurrentState],
-                            ...row
-                        };
-                    } else if (row.addedByServer) {
-                        /**
-             * Note: This is a known limitation of computed array and block rows
-             * If a new row was added by the server, we append it to the _end_ of this array
-             * This is because the client is the source of truth, and it has arrays ordered in a certain position
-             * For example, the user may have re-ordered rows client-side while a long running request is processing
-             * This means that we _cannot_ slice a new row into the second position on the server, for example
-             * By the time it gets back to the client, its index is stale
-             */ const newRow = {
-                            ...row
-                        };
-                        delete newRow.addedByServer;
-                        newState[path].rows.push(newRow);
-                    }
-                });
-                /**
-         * Sync the value field to match the actual row count after merging.
-         * Client is source of truth for row count when rows were added/removed during the request.
-         */ if ('value' in incomingField && newState[path].rows.length !== incomingField.value) {
-                    newState[path].value = newState[path].rows.length;
-                }
-            }
+        * Sync the value field to match the actual row count after merging.
+        * Client is source of truth for row count when rows were added/removed during the request.
+        */
+        if ('value' in incomingField && newState[path].rows.length !== incomingField.value) {
+          newState[path].value = newState[path].rows.length;
         }
-        // If `valid` is `undefined`, mark it as `true`
-        if (incomingField.valid !== false) {
-            newState[path].valid = true;
-        }
-        // If `passesCondition` is `undefined`, mark it as `true`
-        if (incomingField.passesCondition !== false) {
-            newState[path].passesCondition = true;
-        }
-        /**
-     * Undefined values for blocksFilterOptions coming back should be treated as "all blocks allowed" and
-     * should always be merged in.
-     * Without this, an undefined value coming back will incorrectly be ignored, and the previous filter will remain.
-     */ if (!incomingField.blocksFilterOptions) {
-            delete newState[path].blocksFilterOptions;
-        }
-        // Strip away the `addedByServer` property from the client
-        // This will prevent it from being passed back to the server
-        delete newState[path].addedByServer;
+      }
+    }
+    // If `valid` is `undefined`, mark it as `true`
+    if (incomingField.valid !== false) {
+      newState[path].valid = true;
+    }
+    // If `passesCondition` is `undefined`, mark it as `true`
+    if (incomingField.passesCondition !== false) {
+      newState[path].passesCondition = true;
     }
-    // Return the original object reference if the state is unchanged
-    // This will avoid unnecessary re-renders and dependency updates
-    return dequal(newState, currentState) ? currentState : newState;
+    /**
+    * Undefined values for blocksFilterOptions coming back should be treated as "all blocks allowed" and
+    * should always be merged in.
+    * Without this, an undefined value coming back will incorrectly be ignored, and the previous filter will remain.
+    */
+    if (!incomingField.blocksFilterOptions) {
+      delete newState[path].blocksFilterOptions;
+    }
+    // Strip away the `addedByServer` property from the client
+    // This will prevent it from being passed back to the server
+    delete newState[path].addedByServer;
+  }
+  // Return the original object reference if the state is unchanged
+  // This will avoid unnecessary re-renders and dependency updates
+  return dequal(newState, currentState) ? currentState : newState;
 };
-
 //# sourceMappingURL=mergeServerFormState.js.map

package/dist/forms/Form/mergeServerFormState.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/forms/Form/mergeServerFormState.ts"],"sourcesContent":["'use client'\nimport type { FormState } from 'payload'\n\nimport { dequal } from 'dequal/lite' // lite: no need for Map and Set support\n\n/**\n * If true, will accept all values from the server, overriding any current values in local state.\n * Can also provide an options object for more granular control.\n */\nexport type AcceptValues =\n  | {\n      /**\n       * When `false`, will accept the values from the server _UNLESS_ the value has been modified locally since the request was made.\n       * This is useful for autosave, for example, where hooks may have modified the field's value on the server while you were still making changes.\n       * @default undefined\n       */\n      overrideLocalChanges?: boolean\n    }\n  | boolean\n\ntype Args = {\n  acceptValues?: AcceptValues\n  currentState?: FormState\n  incomingState: FormState\n}\n\n/**\n * Parses an array field path to extract the array path, row index, and field path.\n * Handles nested arrays by finding the deepest numeric index.\n *\n * @param path - The field path to parse (e.g., 'array.1.text' or 'blocks.0.items.1.title')\n * @returns Object with arrayPath, rowIndex, and fieldPath, or null if not an array field\n *\n * @example\n * parseArrayFieldPath('array.1.text')\n * // Returns: { arrayPath: 'array', rowIndex: 1, fieldPath: 'text' }\n *\n * @example\n * parseArrayFieldPath('blocks.0.items.1.title')\n * // Returns: { arrayPath: 'blocks.0.items', rowIndex: 1, fieldPath: 'title' }\n */\nfunction parseArrayFieldPath(path: string): {\n  arrayPath: string\n  fieldPath: string\n  rowIndex: number\n} | null {\n  const segments = path.split('.')\n\n  // Find the last numeric index (indicates array row)\n  let lastNumericIndex = -1\n  for (let i = segments.length - 1; i >= 0; i--) {\n    if (/^\\d+$/.test(segments[i])) {\n      lastNumericIndex = i\n      break\n    }\n  }\n\n  // Not an array field if no numeric index or nothing after it\n  if (lastNumericIndex === -1 || lastNumericIndex === segments.length - 1) {\n    return null\n  }\n\n  return {\n    arrayPath: segments.slice(0, lastNumericIndex).join('.'),\n    fieldPath: segments.slice(lastNumericIndex + 1).join('.'),\n    rowIndex: parseInt(segments[lastNumericIndex], 10),\n  }\n}\n\n/**\n * This function receives form state from the server and intelligently merges it into the client state.\n * The server contains extra properties that the client may not have, e.g. custom components and error states.\n * We typically do not want to merge properties that rely on user input, however, such as values, unless explicitly requested.\n * Doing this would cause the client to lose any local changes to those fields.\n *\n * Note: Local state is the source of truth, not the new server state that is getting merged in. This is critical for array row\n * manipulation specifically, where the user may have added, removed, or reordered rows while a request was pending and is now stale.\n *\n * This function applies some defaults, as well as cleans up the server response in preparation for the client.\n * e.g. it will set `valid` and `passesCondition` to true if undefined, and remove `addedByServer` from the response.\n */\nexport const mergeServerFormState = ({\n  acceptValues,\n  currentState = {},\n  incomingState,\n}: Args): FormState => {\n  const newState = { ...currentState }\n\n  for (const [path, incomingField] of Object.entries(incomingState || {})) {\n    if (!(path in currentState) && !incomingField.addedByServer) {\n      continue\n    }\n\n    /**\n     * If it's a new field added by the server, always accept the value.\n     * Otherwise:\n     *   a. accept all values when explicitly requested, e.g. on submit\n     *   b. only accept values for unmodified fields, e.g. on autosave\n     */\n    let shouldAcceptValue =\n      incomingField.addedByServer ||\n      acceptValues === true ||\n      (typeof acceptValues === 'object' &&\n        acceptValues !== null &&\n        // Note: Must be explicitly `false`, allow `null` or `undefined` to mean true\n        acceptValues.overrideLocalChanges === false &&\n        !currentState[path]?.isModified)\n\n    /**\n     * For array row fields, verify the row IDs match at the given index before accepting\n     * server values. If rows were reordered or deleted while the request was in-flight,\n     * the same index may refer to different rows, and accepting the server value would\n     * overwrite the wrong row's data.\n     *\n     * This guard only applies during autosave. On explicit save (acceptValues === true),\n     * the server response is authoritative and this check is bypassed.\n     */\n    if (shouldAcceptValue && !incomingField.addedByServer && acceptValues !== true) {\n      const parsed = parseArrayFieldPath(path)\n      if (parsed) {\n        const { arrayPath, rowIndex } = parsed\n        const clientRowId = currentState[arrayPath]?.rows?.[rowIndex]?.id\n        const serverRowId = incomingState[arrayPath]?.rows?.[rowIndex]?.id\n\n        if (clientRowId === undefined || (serverRowId && clientRowId !== serverRowId)) {\n          shouldAcceptValue = false\n        }\n      }\n    }\n\n    let sanitizedIncomingField = incomingField\n\n    if (!shouldAcceptValue) {\n      /**\n       * Note: do not delete properties off `incomingField` as this will mutate the original object\n       * Instead, omit them from the destructured object by excluding specific keys\n       * This will also ensure we don't set `undefined` into the result unnecessarily\n       */\n      const { initialValue, value, ...rest } = incomingField\n      sanitizedIncomingField = rest\n    }\n\n    newState[path] = {\n      ...currentState[path],\n      ...sanitizedIncomingField,\n    }\n\n    if (\n      currentState[path] &&\n      'errorPaths' in currentState[path] &&\n      !('errorPaths' in incomingField)\n    ) {\n      newState[path].errorPaths = []\n    }\n\n    /**\n     * Deeply merge the rows array to ensure changes to local state are not lost while the request was pending\n     * For example, the server response could come back with a row which has been deleted on the client\n     * Loop over the incoming rows, if it exists in client side form state, merge in any new properties from the server\n     * Note: read `currentState` and not `newState` here, as the `rows` property have already been merged above\n     *\n     * On explicit save (acceptValues === true), the server is authoritative - accept server row order.\n     * On autosave (acceptValues !== true), the client is source of truth - use ID-based matching.\n     */\n    if (Array.isArray(incomingField.rows) && path in currentState) {\n      if (acceptValues === true) {\n        // Explicit save: server is authoritative, use index-based merging\n        newState[path].rows = incomingField.rows.map((serverRow, index) => ({\n          ...(currentState[path]?.rows?.[index] || {}),\n          ...serverRow,\n        }))\n      } else {\n        // Autosave: client is source of truth, use ID-based matching\n        newState[path].rows = [...(currentState[path]?.rows || [])] // shallow copy to avoid mutating the original array\n\n        incomingField.rows.forEach((row) => {\n          const indexInCurrentState = currentState[path].rows?.findIndex(\n            (existingRow) => existingRow.id === row.id,\n          )\n\n          if (indexInCurrentState > -1) {\n            newState[path].rows[indexInCurrentState] = {\n              ...currentState[path].rows[indexInCurrentState],\n              ...row,\n            }\n          } else if (row.addedByServer) {\n            /**\n             * Note: This is a known limitation of computed array and block rows\n             * If a new row was added by the server, we append it to the _end_ of this array\n             * This is because the client is the source of truth, and it has arrays ordered in a certain position\n             * For example, the user may have re-ordered rows client-side while a long running request is processing\n             * This means that we _cannot_ slice a new row into the second position on the server, for example\n             * By the time it gets back to the client, its index is stale\n             */\n            const newRow = { ...row }\n            delete newRow.addedByServer\n            newState[path].rows.push(newRow)\n          }\n        })\n\n        /**\n         * Sync the value field to match the actual row count after merging.\n         * Client is source of truth for row count when rows were added/removed during the request.\n         */\n        if ('value' in incomingField && newState[path].rows.length !== incomingField.value) {\n          newState[path].value = newState[path].rows.length\n        }\n      }\n    }\n\n    // If `valid` is `undefined`, mark it as `true`\n    if (incomingField.valid !== false) {\n      newState[path].valid = true\n    }\n\n    // If `passesCondition` is `undefined`, mark it as `true`\n    if (incomingField.passesCondition !== false) {\n      newState[path].passesCondition = true\n    }\n\n    /**\n     * Undefined values for blocksFilterOptions coming back should be treated as \"all blocks allowed\" and\n     * should always be merged in.\n     * Without this, an undefined value coming back will incorrectly be ignored, and the previous filter will remain.\n     */\n    if (!incomingField.blocksFilterOptions) {\n      delete newState[path].blocksFilterOptions\n    }\n\n    // Strip away the `addedByServer` property from the client\n    // This will prevent it from being passed back to the server\n    delete newState[path].addedByServer\n  }\n\n  // Return the original object reference if the state is unchanged\n  // This will avoid unnecessary re-renders and dependency updates\n  return dequal(newState, currentState) ? currentState : newState\n}\n"],"names":["dequal","parseArrayFieldPath","path","segments","split","lastNumericIndex","i","length","test","arrayPath","slice","join","fieldPath","rowIndex","parseInt","mergeServerFormState","acceptValues","currentState","incomingState","newState","incomingField","Object","entries","addedByServer","shouldAcceptValue","overrideLocalChanges","isModified","parsed","clientRowId","rows","id","serverRowId","undefined","sanitizedIncomingField","initialValue","value","rest","errorPaths","Array","isArray","map","serverRow","index","forEach","row","indexInCurrentState","findIndex","existingRow","newRow","push","valid","passesCondition","blocksFilterOptions"],"mappings":"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"}
+{"version":3,"file":"mergeServerFormState.js","names":["dequal","parseArrayFieldPath","path","segments","split","lastNumericIndex","i","length","test","arrayPath","slice","join","fieldPath","rowIndex","parseInt","mergeServerFormState","acceptValues","currentState","incomingState","newState","incomingField","Object","entries","addedByServer","shouldAcceptValue","overrideLocalChanges","isModified","parsed","clientRowId","rows","id","serverRowId","undefined","sanitizedIncomingField","initialValue","value","rest","errorPaths","Array","isArray","map","serverRow","index","forEach","row","indexInCurrentState","findIndex","existingRow","newRow","push","valid","passesCondition","blocksFilterOptions"],"sources":["../../../src/forms/Form/mergeServerFormState.ts"],"sourcesContent":["'use client'\nimport type { FormState } from 'payload'\n\nimport { dequal } from 'dequal/lite' // lite: no need for Map and Set support\n\n/**\n * If true, will accept all values from the server, overriding any current values in local state.\n * Can also provide an options object for more granular control.\n */\nexport type AcceptValues =\n  | {\n      /**\n       * When `false`, will accept the values from the server _UNLESS_ the value has been modified locally since the request was made.\n       * This is useful for autosave, for example, where hooks may have modified the field's value on the server while you were still making changes.\n       * @default undefined\n       */\n      overrideLocalChanges?: boolean\n    }\n  | boolean\n\ntype Args = {\n  acceptValues?: AcceptValues\n  currentState?: FormState\n  incomingState: FormState\n}\n\n/**\n * Parses an array field path to extract the array path, row index, and field path.\n * Handles nested arrays by finding the deepest numeric index.\n *\n * @param path - The field path to parse (e.g., 'array.1.text' or 'blocks.0.items.1.title')\n * @returns Object with arrayPath, rowIndex, and fieldPath, or null if not an array field\n *\n * @example\n * parseArrayFieldPath('array.1.text')\n * // Returns: { arrayPath: 'array', rowIndex: 1, fieldPath: 'text' }\n *\n * @example\n * parseArrayFieldPath('blocks.0.items.1.title')\n * // Returns: { arrayPath: 'blocks.0.items', rowIndex: 1, fieldPath: 'title' }\n */\nfunction parseArrayFieldPath(path: string): {\n  arrayPath: string\n  fieldPath: string\n  rowIndex: number\n} | null {\n  const segments = path.split('.')\n\n  // Find the last numeric index (indicates array row)\n  let lastNumericIndex = -1\n  for (let i = segments.length - 1; i >= 0; i--) {\n    if (/^\\d+$/.test(segments[i])) {\n      lastNumericIndex = i\n      break\n    }\n  }\n\n  // Not an array field if no numeric index or nothing after it\n  if (lastNumericIndex === -1 || lastNumericIndex === segments.length - 1) {\n    return null\n  }\n\n  return {\n    arrayPath: segments.slice(0, lastNumericIndex).join('.'),\n    fieldPath: segments.slice(lastNumericIndex + 1).join('.'),\n    rowIndex: parseInt(segments[lastNumericIndex], 10),\n  }\n}\n\n/**\n * This function receives form state from the server and intelligently merges it into the client state.\n * The server contains extra properties that the client may not have, e.g. custom components and error states.\n * We typically do not want to merge properties that rely on user input, however, such as values, unless explicitly requested.\n * Doing this would cause the client to lose any local changes to those fields.\n *\n * Note: Local state is the source of truth, not the new server state that is getting merged in. This is critical for array row\n * manipulation specifically, where the user may have added, removed, or reordered rows while a request was pending and is now stale.\n *\n * This function applies some defaults, as well as cleans up the server response in preparation for the client.\n * e.g. it will set `valid` and `passesCondition` to true if undefined, and remove `addedByServer` from the response.\n */\nexport const mergeServerFormState = ({\n  acceptValues,\n  currentState = {},\n  incomingState,\n}: Args): FormState => {\n  const newState = { ...currentState }\n\n  for (const [path, incomingField] of Object.entries(incomingState || {})) {\n    if (!(path in currentState) && !incomingField.addedByServer) {\n      continue\n    }\n\n    /**\n     * If it's a new field added by the server, always accept the value.\n     * Otherwise:\n     *   a. accept all values when explicitly requested, e.g. on submit\n     *   b. only accept values for unmodified fields, e.g. on autosave\n     */\n    let shouldAcceptValue =\n      incomingField.addedByServer ||\n      acceptValues === true ||\n      (typeof acceptValues === 'object' &&\n        acceptValues !== null &&\n        // Note: Must be explicitly `false`, allow `null` or `undefined` to mean true\n        acceptValues.overrideLocalChanges === false &&\n        !currentState[path]?.isModified)\n\n    /**\n     * For array row fields, verify the row IDs match at the given index before accepting\n     * server values. If rows were reordered or deleted while the request was in-flight,\n     * the same index may refer to different rows, and accepting the server value would\n     * overwrite the wrong row's data.\n     *\n     * This guard only applies during autosave. On explicit save (acceptValues === true),\n     * the server response is authoritative and this check is bypassed.\n     */\n    if (shouldAcceptValue && !incomingField.addedByServer && acceptValues !== true) {\n      const parsed = parseArrayFieldPath(path)\n      if (parsed) {\n        const { arrayPath, rowIndex } = parsed\n        const clientRowId = currentState[arrayPath]?.rows?.[rowIndex]?.id\n        const serverRowId = incomingState[arrayPath]?.rows?.[rowIndex]?.id\n\n        if (clientRowId === undefined || (serverRowId && clientRowId !== serverRowId)) {\n          shouldAcceptValue = false\n        }\n      }\n    }\n\n    let sanitizedIncomingField = incomingField\n\n    if (!shouldAcceptValue) {\n      /**\n       * Note: do not delete properties off `incomingField` as this will mutate the original object\n       * Instead, omit them from the destructured object by excluding specific keys\n       * This will also ensure we don't set `undefined` into the result unnecessarily\n       */\n      const { initialValue, value, ...rest } = incomingField\n      sanitizedIncomingField = rest\n    }\n\n    newState[path] = {\n      ...currentState[path],\n      ...sanitizedIncomingField,\n    }\n\n    if (\n      currentState[path] &&\n      'errorPaths' in currentState[path] &&\n      !('errorPaths' in incomingField)\n    ) {\n      newState[path].errorPaths = []\n    }\n\n    /**\n     * Deeply merge the rows array to ensure changes to local state are not lost while the request was pending\n     * For example, the server response could come back with a row which has been deleted on the client\n     * Loop over the incoming rows, if it exists in client side form state, merge in any new properties from the server\n     * Note: read `currentState` and not `newState` here, as the `rows` property have already been merged above\n     *\n     * On explicit save (acceptValues === true), the server is authoritative - accept server row order.\n     * On autosave (acceptValues !== true), the client is source of truth - use ID-based matching.\n     */\n    if (Array.isArray(incomingField.rows) && path in currentState) {\n      if (acceptValues === true) {\n        // Explicit save: server is authoritative, use index-based merging\n        newState[path].rows = incomingField.rows.map((serverRow, index) => ({\n          ...(currentState[path]?.rows?.[index] || {}),\n          ...serverRow,\n        }))\n      } else {\n        // Autosave: client is source of truth, use ID-based matching\n        newState[path].rows = [...(currentState[path]?.rows || [])] // shallow copy to avoid mutating the original array\n\n        incomingField.rows.forEach((row) => {\n          const indexInCurrentState = currentState[path].rows?.findIndex(\n            (existingRow) => existingRow.id === row.id,\n          )\n\n          if (indexInCurrentState > -1) {\n            newState[path].rows[indexInCurrentState] = {\n              ...currentState[path].rows[indexInCurrentState],\n              ...row,\n            }\n          } else if (row.addedByServer) {\n            /**\n             * Note: This is a known limitation of computed array and block rows\n             * If a new row was added by the server, we append it to the _end_ of this array\n             * This is because the client is the source of truth, and it has arrays ordered in a certain position\n             * For example, the user may have re-ordered rows client-side while a long running request is processing\n             * This means that we _cannot_ slice a new row into the second position on the server, for example\n             * By the time it gets back to the client, its index is stale\n             */\n            const newRow = { ...row }\n            delete newRow.addedByServer\n            newState[path].rows.push(newRow)\n          }\n        })\n\n        /**\n         * Sync the value field to match the actual row count after merging.\n         * Client is source of truth for row count when rows were added/removed during the request.\n         */\n        if ('value' in incomingField && newState[path].rows.length !== incomingField.value) {\n          newState[path].value = newState[path].rows.length\n        }\n      }\n    }\n\n    // If `valid` is `undefined`, mark it as `true`\n    if (incomingField.valid !== false) {\n      newState[path].valid = true\n    }\n\n    // If `passesCondition` is `undefined`, mark it as `true`\n    if (incomingField.passesCondition !== false) {\n      newState[path].passesCondition = true\n    }\n\n    /**\n     * Undefined values for blocksFilterOptions coming back should be treated as \"all blocks allowed\" and\n     * should always be merged in.\n     * Without this, an undefined value coming back will incorrectly be ignored, and the previous filter will remain.\n     */\n    if (!incomingField.blocksFilterOptions) {\n      delete newState[path].blocksFilterOptions\n    }\n\n    // Strip away the `addedByServer` property from the client\n    // This will prevent it from being passed back to the server\n    delete newState[path].addedByServer\n  }\n\n  // Return the original object reference if the state is unchanged\n  // This will avoid unnecessary re-renders and dependency updates\n  return dequal(newState, currentState) ? currentState : newState\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/forms/Form/reduceToSerializableFields.js

@@ -1,26 +1,23 @@
-const blacklistedKeys = [
-    'validate',
-    'customComponents'
-];
-const sanitizeField = (incomingField)=>{
-    const field = {
-        ...incomingField
-    };
-    // shallow copy, as we only need to remove top-level keys
-    for (const key of blacklistedKeys){
-        delete field[key];
-    }
-    return field;
+const blacklistedKeys = ['validate', 'customComponents'];
+const sanitizeField = incomingField => {
+  const field = {
+    ...incomingField
+  } // shallow copy, as we only need to remove top-level keys
+;
+  for (const key of blacklistedKeys) {
+    delete field[key];
+  }
+  return field;
 };
 /**
  * Takes in FormState and removes fields that are not serializable.
  * Returns FormState without blacklisted keys.
- */ export const reduceToSerializableFields = (fields)=>{
-    const result = {};
-    for(const key in fields){
-        result[key] = sanitizeField(fields[key]);
-    }
-    return result;
+ */
+export const reduceToSerializableFields = fields => {
+  const result = {};
+  for (const key in fields) {
+    result[key] = sanitizeField(fields[key]);
+  }
+  return result;
 };
-
 //# sourceMappingURL=reduceToSerializableFields.js.map

package/dist/forms/Form/reduceToSerializableFields.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/forms/Form/reduceToSerializableFields.ts"],"sourcesContent":["import { type FormField, type FormState } from 'payload'\n\ntype BlacklistedKeys = 'customComponents' | 'validate'\nconst blacklistedKeys: BlacklistedKeys[] = ['validate', 'customComponents']\n\nconst sanitizeField = (incomingField: FormField): FormField => {\n  const field = { ...incomingField } // shallow copy, as we only need to remove top-level keys\n\n  for (const key of blacklistedKeys) {\n    delete field[key]\n  }\n\n  return field\n}\n\n/**\n * Takes in FormState and removes fields that are not serializable.\n * Returns FormState without blacklisted keys.\n */\nexport const reduceToSerializableFields = (\n  fields: FormState,\n): {\n  [key: string]: Omit<FormField, BlacklistedKeys>\n} => {\n  const result: Record<string, Omit<FormField, BlacklistedKeys>> = {}\n\n  for (const key in fields) {\n    result[key] = sanitizeField(fields[key])\n  }\n\n  return result\n}\n"],"names":["blacklistedKeys","sanitizeField","incomingField","field","key","reduceToSerializableFields","fields","result"],"mappings":"AAGA,MAAMA,kBAAqC;IAAC;IAAY;CAAmB;AAE3E,MAAMC,gBAAgB,CAACC;IACrB,MAAMC,QAAQ;QAAE,GAAGD,aAAa;IAAC;IAAE,yDAAyD;IAE5F,KAAK,MAAME,OAAOJ,gBAAiB;QACjC,OAAOG,KAAK,CAACC,IAAI;IACnB;IAEA,OAAOD;AACT;AAEA;;;CAGC,GACD,OAAO,MAAME,6BAA6B,CACxCC;IAIA,MAAMC,SAA2D,CAAC;IAElE,IAAK,MAAMH,OAAOE,OAAQ;QACxBC,MAAM,CAACH,IAAI,GAAGH,cAAcK,MAAM,CAACF,IAAI;IACzC;IAEA,OAAOG;AACT,EAAC"}
+{"version":3,"file":"reduceToSerializableFields.js","names":["blacklistedKeys","sanitizeField","incomingField","field","key","reduceToSerializableFields","fields","result"],"sources":["../../../src/forms/Form/reduceToSerializableFields.ts"],"sourcesContent":["import { type FormField, type FormState } from 'payload'\n\ntype BlacklistedKeys = 'customComponents' | 'validate'\nconst blacklistedKeys: BlacklistedKeys[] = ['validate', 'customComponents']\n\nconst sanitizeField = (incomingField: FormField): FormField => {\n  const field = { ...incomingField } // shallow copy, as we only need to remove top-level keys\n\n  for (const key of blacklistedKeys) {\n    delete field[key]\n  }\n\n  return field\n}\n\n/**\n * Takes in FormState and removes fields that are not serializable.\n * Returns FormState without blacklisted keys.\n */\nexport const reduceToSerializableFields = (\n  fields: FormState,\n): {\n  [key: string]: Omit<FormField, BlacklistedKeys>\n} => {\n  const result: Record<string, Omit<FormField, BlacklistedKeys>> = {}\n\n  for (const key in fields) {\n    result[key] = sanitizeField(fields[key])\n  }\n\n  return result\n}\n"],"mappings":"AAGA,MAAMA,eAAA,GAAqC,CAAC,YAAY,mBAAmB;AAE3E,MAAMC,aAAA,GAAiBC,aAAA;EACrB,MAAMC,KAAA,GAAQ;IAAE,GAAGD;EAAc,EAAE;AAAA;EAEnC,KAAK,MAAME,GAAA,IAAOJ,eAAA,EAAiB;IACjC,OAAOG,KAAK,CAACC,GAAA,CAAI;EACnB;EAEA,OAAOD,KAAA;AACT;AAEA;;;;AAIA,OAAO,MAAME,0BAAA,GACXC,MAAA;EAIA,MAAMC,MAAA,GAA2D,CAAC;EAElE,KAAK,MAAMH,GAAA,IAAOE,MAAA,EAAQ;IACxBC,MAAM,CAACH,GAAA,CAAI,GAAGH,aAAA,CAAcK,MAAM,CAACF,GAAA,CAAI;EACzC;EAEA,OAAOG,MAAA;AACT","ignoreList":[]}

package/dist/forms/Form/rowHelpers.js

@@ -1,31 +1,38 @@
 'use client';
-export const extractRowsAndCollapsedIDs = ({ collapsed, rowID, rows })=>{
-    return rows.reduce((acc, row)=>{
-        if (rowID === row.id) {
-            row.collapsed = collapsed;
-        }
-        if (row.collapsed) {
-            acc.collapsedIDs.push(row.id);
-        }
-        acc.updatedRows.push(row);
-        return acc;
-    }, {
-        collapsedIDs: [],
-        updatedRows: []
-    });
+
+export const extractRowsAndCollapsedIDs = ({
+  collapsed,
+  rowID,
+  rows
+}) => {
+  return rows.reduce((acc, row) => {
+    if (rowID === row.id) {
+      row.collapsed = collapsed;
+    }
+    if (row.collapsed) {
+      acc.collapsedIDs.push(row.id);
+    }
+    acc.updatedRows.push(row);
+    return acc;
+  }, {
+    collapsedIDs: [],
+    updatedRows: []
+  });
 };
-export const toggleAllRows = ({ collapsed, rows })=>{
-    return rows.reduce((acc, row)=>{
-        row.collapsed = collapsed;
-        if (collapsed) {
-            acc.collapsedIDs.push(row.id);
-        }
-        acc.updatedRows.push(row);
-        return acc;
-    }, {
-        collapsedIDs: [],
-        updatedRows: []
-    });
+export const toggleAllRows = ({
+  collapsed,
+  rows
+}) => {
+  return rows.reduce((acc, row) => {
+    row.collapsed = collapsed;
+    if (collapsed) {
+      acc.collapsedIDs.push(row.id);
+    }
+    acc.updatedRows.push(row);
+    return acc;
+  }, {
+    collapsedIDs: [],
+    updatedRows: []
+  });
 };
-
 //# sourceMappingURL=rowHelpers.js.map

package/dist/forms/Form/rowHelpers.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/forms/Form/rowHelpers.ts"],"sourcesContent":["'use client'\nimport type { Row } from 'payload'\n\nexport const extractRowsAndCollapsedIDs = ({\n  collapsed,\n  rowID,\n  rows,\n}: {\n  collapsed: boolean\n  rowID: string\n  rows: Row[]\n}): {\n  collapsedIDs: string[]\n  updatedRows: Row[]\n} => {\n  return rows.reduce(\n    (acc, row) => {\n      if (rowID === row.id) {\n        row.collapsed = collapsed\n      }\n      if (row.collapsed) {\n        acc.collapsedIDs.push(row.id)\n      }\n      acc.updatedRows.push(row)\n      return acc\n    },\n    {\n      collapsedIDs: [],\n      updatedRows: [],\n    },\n  )\n}\n\nexport const toggleAllRows = ({\n  collapsed,\n  rows,\n}): {\n  collapsedIDs: string[]\n  updatedRows: Row[]\n} => {\n  return rows.reduce(\n    (acc, row) => {\n      row.collapsed = collapsed\n      if (collapsed) {\n        acc.collapsedIDs.push(row.id)\n      }\n      acc.updatedRows.push(row)\n      return acc\n    },\n    {\n      collapsedIDs: [],\n      updatedRows: [],\n    },\n  )\n}\n"],"names":["extractRowsAndCollapsedIDs","collapsed","rowID","rows","reduce","acc","row","id","collapsedIDs","push","updatedRows","toggleAllRows"],"mappings":"AAAA;AAGA,OAAO,MAAMA,6BAA6B,CAAC,EACzCC,SAAS,EACTC,KAAK,EACLC,IAAI,EAKL;IAIC,OAAOA,KAAKC,MAAM,CAChB,CAACC,KAAKC;QACJ,IAAIJ,UAAUI,IAAIC,EAAE,EAAE;YACpBD,IAAIL,SAAS,GAAGA;QAClB;QACA,IAAIK,IAAIL,SAAS,EAAE;YACjBI,IAAIG,YAAY,CAACC,IAAI,CAACH,IAAIC,EAAE;QAC9B;QACAF,IAAIK,WAAW,CAACD,IAAI,CAACH;QACrB,OAAOD;IACT,GACA;QACEG,cAAc,EAAE;QAChBE,aAAa,EAAE;IACjB;AAEJ,EAAC;AAED,OAAO,MAAMC,gBAAgB,CAAC,EAC5BV,SAAS,EACTE,IAAI,EACL;IAIC,OAAOA,KAAKC,MAAM,CAChB,CAACC,KAAKC;QACJA,IAAIL,SAAS,GAAGA;QAChB,IAAIA,WAAW;YACbI,IAAIG,YAAY,CAACC,IAAI,CAACH,IAAIC,EAAE;QAC9B;QACAF,IAAIK,WAAW,CAACD,IAAI,CAACH;QACrB,OAAOD;IACT,GACA;QACEG,cAAc,EAAE;QAChBE,aAAa,EAAE;IACjB;AAEJ,EAAC"}
+{"version":3,"file":"rowHelpers.js","names":["extractRowsAndCollapsedIDs","collapsed","rowID","rows","reduce","acc","row","id","collapsedIDs","push","updatedRows","toggleAllRows"],"sources":["../../../src/forms/Form/rowHelpers.ts"],"sourcesContent":["'use client'\nimport type { Row } from 'payload'\n\nexport const extractRowsAndCollapsedIDs = ({\n  collapsed,\n  rowID,\n  rows,\n}: {\n  collapsed: boolean\n  rowID: string\n  rows: Row[]\n}): {\n  collapsedIDs: string[]\n  updatedRows: Row[]\n} => {\n  return rows.reduce(\n    (acc, row) => {\n      if (rowID === row.id) {\n        row.collapsed = collapsed\n      }\n      if (row.collapsed) {\n        acc.collapsedIDs.push(row.id)\n      }\n      acc.updatedRows.push(row)\n      return acc\n    },\n    {\n      collapsedIDs: [],\n      updatedRows: [],\n    },\n  )\n}\n\nexport const toggleAllRows = ({\n  collapsed,\n  rows,\n}): {\n  collapsedIDs: string[]\n  updatedRows: Row[]\n} => {\n  return rows.reduce(\n    (acc, row) => {\n      row.collapsed = collapsed\n      if (collapsed) {\n        acc.collapsedIDs.push(row.id)\n      }\n      acc.updatedRows.push(row)\n      return acc\n    },\n    {\n      collapsedIDs: [],\n      updatedRows: [],\n    },\n  )\n}\n"],"mappings":"AAAA;;AAGA,OAAO,MAAMA,0BAAA,GAA6BA,CAAC;EACzCC,SAAS;EACTC,KAAK;EACLC;AAAI,CAKL;EAIC,OAAOA,IAAA,CAAKC,MAAM,CAChB,CAACC,GAAA,EAAKC,GAAA;IACJ,IAAIJ,KAAA,KAAUI,GAAA,CAAIC,EAAE,EAAE;MACpBD,GAAA,CAAIL,SAAS,GAAGA,SAAA;IAClB;IACA,IAAIK,GAAA,CAAIL,SAAS,EAAE;MACjBI,GAAA,CAAIG,YAAY,CAACC,IAAI,CAACH,GAAA,CAAIC,EAAE;IAC9B;IACAF,GAAA,CAAIK,WAAW,CAACD,IAAI,CAACH,GAAA;IACrB,OAAOD,GAAA;EACT,GACA;IACEG,YAAA,EAAc,EAAE;IAChBE,WAAA,EAAa;EACf;AAEJ;AAEA,OAAO,MAAMC,aAAA,GAAgBA,CAAC;EAC5BV,SAAS;EACTE;AAAI,CACL;EAIC,OAAOA,IAAA,CAAKC,MAAM,CAChB,CAACC,GAAA,EAAKC,GAAA;IACJA,GAAA,CAAIL,SAAS,GAAGA,SAAA;IAChB,IAAIA,SAAA,EAAW;MACbI,GAAA,CAAIG,YAAY,CAACC,IAAI,CAACH,GAAA,CAAIC,EAAE;IAC9B;IACAF,GAAA,CAAIK,WAAW,CAACD,IAAI,CAACH,GAAA;IACrB,OAAOD,GAAA;EACT,GACA;IACEG,YAAA,EAAc,EAAE;IAChBE,WAAA,EAAa;EACf;AAEJ","ignoreList":[]}

package/dist/forms/Form/rows.js

@@ -1,38 +1,38 @@
 'use client';
-export const separateRows = (path, fields)=>{
-    const remainingFields = {};
-    const rows = Object.entries(fields).reduce((incomingRows, [fieldPath, field])=>{
-        const newRows = incomingRows;
-        if (fieldPath.indexOf(`${path}.`) === 0) {
-            const [rowIndex] = fieldPath.replace(`${path}.`, '').split('.');
-            if (!newRows[rowIndex]) {
-                newRows[rowIndex] = {};
-            }
-            newRows[rowIndex][fieldPath.replace(`${path}.${String(rowIndex)}.`, '')] = {
-                ...field
-            };
-        } else {
-            remainingFields[fieldPath] = field;
-        }
-        return newRows;
-    }, []);
-    return {
-        remainingFields,
-        rows
-    };
+
+export const separateRows = (path, fields) => {
+  const remainingFields = {};
+  const rows = Object.entries(fields).reduce((incomingRows, [fieldPath, field]) => {
+    const newRows = incomingRows;
+    if (fieldPath.indexOf(`${path}.`) === 0) {
+      const [rowIndex] = fieldPath.replace(`${path}.`, '').split('.');
+      if (!newRows[rowIndex]) {
+        newRows[rowIndex] = {};
+      }
+      newRows[rowIndex][fieldPath.replace(`${path}.${String(rowIndex)}.`, '')] = {
+        ...field
+      };
+    } else {
+      remainingFields[fieldPath] = field;
+    }
+    return newRows;
+  }, []);
+  return {
+    remainingFields,
+    rows
+  };
 };
-export const flattenRows = (path, rows)=>{
-    return rows.reduce((fields, row, i)=>({
-            ...fields,
-            ...Object.entries(row).reduce((subFields, [subPath, subField])=>{
-                return {
-                    ...subFields,
-                    [`${path}.${i}.${subPath}`]: {
-                        ...subField
-                    }
-                };
-            }, {})
-        }), {});
+export const flattenRows = (path, rows) => {
+  return rows.reduce((fields, row, i) => ({
+    ...fields,
+    ...Object.entries(row).reduce((subFields, [subPath, subField]) => {
+      return {
+        ...subFields,
+        [`${path}.${i}.${subPath}`]: {
+          ...subField
+        }
+      };
+    }, {})
+  }), {});
 };
-
 //# sourceMappingURL=rows.js.map