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

package/dist/forms/Form/mergeServerFormState.js

@@ -1,7 +1,14 @@
 '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.
  *
@@ -15,26 +22,25 @@ import { dequal } from 'dequal/lite'; // lite: no need for Map and Set support
  * @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;
+ */ 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;
     }
-  }
-  // 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)
-  };
+    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.
@@ -47,145 +53,129 @@ function parseArrayFieldPath(path) {
  *
  * 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;
-        }
-      }
-    }
-    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
+ */ export const mergeServerFormState = ({ acceptValues, currentState = {}, incomingState })=>{
+    const newState = {
+        ...currentState
     };
-    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) {
+    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) {
             /**
-            * 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);
-          }
-        });
+       * 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 = [];
+        }
         /**
-        * 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;
+     * 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;
+                }
+            }
         }
-      }
-    }
-    // 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;
+        // 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;
     }
-    // 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;
+    // 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,"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":[]}
+{"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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"}

package/dist/forms/Form/reduceToSerializableFields.js

@@ -1,23 +1,26 @@
-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,"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":[]}
+{"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"}

package/dist/forms/Form/rowHelpers.js

@@ -1,38 +1,31 @@
 '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,"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":[]}
+{"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"}

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 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 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
+                    }
+                };
+            }, {})
+        }), {});
+};
+
 //# sourceMappingURL=rows.js.map