@depup/payload 3.79.1-depup.0

package/dist/fields/hooks/beforeValidate/getFallbackValue.js

@@ -0,0 +1,20 @@
+import { getDefaultValue } from '../../getDefaultValue.js';
+import { cloneDataFromOriginalDoc } from '../beforeChange/cloneDataFromOriginalDoc.js';
+export async function getFallbackValue({ field, req, siblingDoc }) {
+    let fallbackValue = undefined;
+    if ('name' in field && field.name) {
+        if (typeof siblingDoc[field.name] !== 'undefined') {
+            fallbackValue = cloneDataFromOriginalDoc(siblingDoc[field.name]);
+        } else if ('defaultValue' in field && typeof field.defaultValue !== 'undefined') {
+            fallbackValue = await getDefaultValue({
+                defaultValue: field.defaultValue,
+                locale: req.locale || '',
+                req,
+                user: req.user
+            });
+        }
+    }
+    return fallbackValue;
+}
+
+//# sourceMappingURL=getFallbackValue.js.map

package/dist/fields/hooks/beforeValidate/getFallbackValue.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/fields/hooks/beforeValidate/getFallbackValue.ts"],"sourcesContent":["import type { JsonObject, JsonValue, PayloadRequest } from '../../../types/index.js'\nimport type { FieldAffectingData } from '../../config/types.js'\n\nimport { getDefaultValue } from '../../getDefaultValue.js'\nimport { cloneDataFromOriginalDoc } from '../beforeChange/cloneDataFromOriginalDoc.js'\n\nexport async function getFallbackValue({\n  field,\n  req,\n  siblingDoc,\n}: {\n  field: FieldAffectingData\n  req: PayloadRequest\n  siblingDoc: JsonObject\n}): Promise<JsonValue> {\n  let fallbackValue: JsonValue = undefined\n  if ('name' in field && field.name) {\n    if (typeof siblingDoc[field.name] !== 'undefined') {\n      fallbackValue = cloneDataFromOriginalDoc(siblingDoc[field.name])\n    } else if ('defaultValue' in field && typeof field.defaultValue !== 'undefined') {\n      fallbackValue = await getDefaultValue({\n        defaultValue: field.defaultValue,\n        locale: req.locale || '',\n        req,\n        user: req.user,\n      })\n    }\n  }\n\n  return fallbackValue\n}\n"],"names":["getDefaultValue","cloneDataFromOriginalDoc","getFallbackValue","field","req","siblingDoc","fallbackValue","undefined","name","defaultValue","locale","user"],"mappings":"AAGA,SAASA,eAAe,QAAQ,2BAA0B;AAC1D,SAASC,wBAAwB,QAAQ,8CAA6C;AAEtF,OAAO,eAAeC,iBAAiB,EACrCC,KAAK,EACLC,GAAG,EACHC,UAAU,EAKX;IACC,IAAIC,gBAA2BC;IAC/B,IAAI,UAAUJ,SAASA,MAAMK,IAAI,EAAE;QACjC,IAAI,OAAOH,UAAU,CAACF,MAAMK,IAAI,CAAC,KAAK,aAAa;YACjDF,gBAAgBL,yBAAyBI,UAAU,CAACF,MAAMK,IAAI,CAAC;QACjE,OAAO,IAAI,kBAAkBL,SAAS,OAAOA,MAAMM,YAAY,KAAK,aAAa;YAC/EH,gBAAgB,MAAMN,gBAAgB;gBACpCS,cAAcN,MAAMM,YAAY;gBAChCC,QAAQN,IAAIM,MAAM,IAAI;gBACtBN;gBACAO,MAAMP,IAAIO,IAAI;YAChB;QACF;IACF;IAEA,OAAOL;AACT"}

package/dist/fields/hooks/beforeValidate/index.d.ts

@@ -0,0 +1,27 @@
+import type { SanitizedCollectionConfig } from '../../../collections/config/types.js';
+import type { SanitizedGlobalConfig } from '../../../globals/config/types.js';
+import type { JsonObject, PayloadRequest } from '../../../types/index.js';
+import { type RequestContext } from '../../../index.js';
+type Args<T extends JsonObject> = {
+    collection: null | SanitizedCollectionConfig;
+    context: RequestContext;
+    data: T;
+    doc?: T;
+    duplicate?: boolean;
+    global: null | SanitizedGlobalConfig;
+    id?: number | string;
+    operation: 'create' | 'update';
+    overrideAccess: boolean;
+    req: PayloadRequest;
+};
+/**
+ * This function is responsible for the following actions, in order:
+ * - Sanitize incoming data
+ * - Execute field hooks
+ * - Execute field access control
+ * - Merge original document data into incoming data
+ * - Compute default values for undefined fields
+ */
+export declare const beforeValidate: <T extends JsonObject>({ id, collection, context, data: incomingData, doc, global, operation, overrideAccess, req, }: Args<T>) => Promise<T>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/fields/hooks/beforeValidate/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/fields/hooks/beforeValidate/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAA;AACrF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAA;AAC7E,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAEzE,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAGvD,KAAK,IAAI,CAAC,CAAC,SAAS,UAAU,IAAI;IAChC,UAAU,EAAE,IAAI,GAAG,yBAAyB,CAAA;IAC5C,OAAO,EAAE,cAAc,CAAA;IACvB,IAAI,EAAE,CAAC,CAAA;IACP,GAAG,CAAC,EAAE,CAAC,CAAA;IACP,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,MAAM,EAAE,IAAI,GAAG,qBAAqB,CAAA;IACpC,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACpB,SAAS,EAAE,QAAQ,GAAG,QAAQ,CAAA;IAC9B,cAAc,EAAE,OAAO,CAAA;IACvB,GAAG,EAAE,cAAc,CAAA;CACpB,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,GAAU,CAAC,SAAS,UAAU,iGAUtD,IAAI,CAAC,CAAC,CAAC,KAAG,OAAO,CAAC,CAAC,CAqBrB,CAAA"}

package/dist/fields/hooks/beforeValidate/index.js

@@ -0,0 +1,31 @@
+import { traverseFields } from './traverseFields.js';
+/**
+ * This function is responsible for the following actions, in order:
+ * - Sanitize incoming data
+ * - Execute field hooks
+ * - Execute field access control
+ * - Merge original document data into incoming data
+ * - Compute default values for undefined fields
+ */ export const beforeValidate = async ({ id, collection, context, data: incomingData, doc, global, operation, overrideAccess, req })=>{
+    await traverseFields({
+        id,
+        collection,
+        context,
+        data: incomingData,
+        doc,
+        fields: collection?.fields || global?.fields,
+        global,
+        operation,
+        overrideAccess,
+        parentIndexPath: '',
+        parentIsLocalized: false,
+        parentPath: '',
+        parentSchemaPath: '',
+        req,
+        siblingData: incomingData,
+        siblingDoc: doc
+    });
+    return incomingData;
+};
+
+//# sourceMappingURL=index.js.map

package/dist/fields/hooks/beforeValidate/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/fields/hooks/beforeValidate/index.ts"],"sourcesContent":["import type { SanitizedCollectionConfig } from '../../../collections/config/types.js'\nimport type { SanitizedGlobalConfig } from '../../../globals/config/types.js'\nimport type { JsonObject, PayloadRequest } from '../../../types/index.js'\n\nimport { type RequestContext } from '../../../index.js'\nimport { traverseFields } from './traverseFields.js'\n\ntype Args<T extends JsonObject> = {\n  collection: null | SanitizedCollectionConfig\n  context: RequestContext\n  data: T\n  doc?: T\n  duplicate?: boolean\n  global: null | SanitizedGlobalConfig\n  id?: number | string\n  operation: 'create' | 'update'\n  overrideAccess: boolean\n  req: PayloadRequest\n}\n\n/**\n * This function is responsible for the following actions, in order:\n * - Sanitize incoming data\n * - Execute field hooks\n * - Execute field access control\n * - Merge original document data into incoming data\n * - Compute default values for undefined fields\n */\nexport const beforeValidate = async <T extends JsonObject>({\n  id,\n  collection,\n  context,\n  data: incomingData,\n  doc,\n  global,\n  operation,\n  overrideAccess,\n  req,\n}: Args<T>): Promise<T> => {\n  await traverseFields({\n    id,\n    collection,\n    context,\n    data: incomingData,\n    doc,\n    fields: (collection?.fields || global?.fields)!,\n    global,\n    operation,\n    overrideAccess,\n    parentIndexPath: '',\n    parentIsLocalized: false,\n    parentPath: '',\n    parentSchemaPath: '',\n    req,\n    siblingData: incomingData,\n    siblingDoc: doc!,\n  })\n\n  return incomingData\n}\n"],"names":["traverseFields","beforeValidate","id","collection","context","data","incomingData","doc","global","operation","overrideAccess","req","fields","parentIndexPath","parentIsLocalized","parentPath","parentSchemaPath","siblingData","siblingDoc"],"mappings":"AAKA,SAASA,cAAc,QAAQ,sBAAqB;AAepD;;;;;;;CAOC,GACD,OAAO,MAAMC,iBAAiB,OAA6B,EACzDC,EAAE,EACFC,UAAU,EACVC,OAAO,EACPC,MAAMC,YAAY,EAClBC,GAAG,EACHC,MAAM,EACNC,SAAS,EACTC,cAAc,EACdC,GAAG,EACK;IACR,MAAMX,eAAe;QACnBE;QACAC;QACAC;QACAC,MAAMC;QACNC;QACAK,QAAST,YAAYS,UAAUJ,QAAQI;QACvCJ;QACAC;QACAC;QACAG,iBAAiB;QACjBC,mBAAmB;QACnBC,YAAY;QACZC,kBAAkB;QAClBL;QACAM,aAAaX;QACbY,YAAYX;IACd;IAEA,OAAOD;AACT,EAAC"}

package/dist/fields/hooks/beforeValidate/promise.d.ts

@@ -0,0 +1,38 @@
+import type { SanitizedCollectionConfig } from '../../../collections/config/types.js';
+import type { SanitizedGlobalConfig } from '../../../globals/config/types.js';
+import type { RequestContext } from '../../../index.js';
+import type { JsonObject, PayloadRequest } from '../../../types/index.js';
+import type { Field, TabAsField } from '../../config/types.js';
+type Args<T> = {
+    /**
+     * Data of the nearest parent block. If no parent block exists, this will be the `undefined`
+     */
+    blockData?: JsonObject;
+    collection: null | SanitizedCollectionConfig;
+    context: RequestContext;
+    data: T;
+    /**
+     * The original data (not modified by any hooks)
+     */
+    doc: T;
+    field: Field | TabAsField;
+    fieldIndex: number;
+    global: null | SanitizedGlobalConfig;
+    id?: number | string;
+    operation: 'create' | 'update';
+    overrideAccess: boolean;
+    parentIndexPath: string;
+    parentIsLocalized: boolean;
+    parentPath: string;
+    parentSchemaPath: string;
+    req: PayloadRequest;
+    siblingData: JsonObject;
+    /**
+     * The original siblingData (not modified by any hooks)
+     */
+    siblingDoc: JsonObject;
+    siblingFields?: (Field | TabAsField)[];
+};
+export declare const promise: <T>({ id, blockData, collection, context, data, doc, field, fieldIndex, global, operation, overrideAccess, parentIndexPath, parentIsLocalized, parentPath, parentSchemaPath, req, siblingData, siblingDoc, siblingFields, }: Args<T>) => Promise<void>;
+export {};
+//# sourceMappingURL=promise.d.ts.map

package/dist/fields/hooks/beforeValidate/promise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise.d.ts","sourceRoot":"","sources":["../../../../src/fields/hooks/beforeValidate/promise.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,yBAAyB,EAAc,MAAM,sCAAsC,CAAA;AACjG,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAA;AAC7E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AACvD,OAAO,KAAK,EAAE,UAAU,EAAa,cAAc,EAAE,MAAM,yBAAyB,CAAA;AACpF,OAAO,KAAK,EAAS,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AASrE,KAAK,IAAI,CAAC,CAAC,IAAI;IACb;;OAEG;IACH,SAAS,CAAC,EAAE,UAAU,CAAA;IACtB,UAAU,EAAE,IAAI,GAAG,yBAAyB,CAAA;IAC5C,OAAO,EAAE,cAAc,CAAA;IACvB,IAAI,EAAE,CAAC,CAAA;IACP;;OAEG;IACH,GAAG,EAAE,CAAC,CAAA;IACN,KAAK,EAAE,KAAK,GAAG,UAAU,CAAA;IACzB,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,IAAI,GAAG,qBAAqB,CAAA;IACpC,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACpB,SAAS,EAAE,QAAQ,GAAG,QAAQ,CAAA;IAC9B,cAAc,EAAE,OAAO,CAAA;IACvB,eAAe,EAAE,MAAM,CAAA;IACvB,iBAAiB,EAAE,OAAO,CAAA;IAC1B,UAAU,EAAE,MAAM,CAAA;IAClB,gBAAgB,EAAE,MAAM,CAAA;IACxB,GAAG,EAAE,cAAc,CAAA;IACnB,WAAW,EAAE,UAAU,CAAA;IACvB;;OAEG;IACH,UAAU,EAAE,UAAU,CAAA;IACtB,aAAa,CAAC,EAAE,CAAC,KAAK,GAAG,UAAU,CAAC,EAAE,CAAA;CACvC,CAAA;AASD,eAAO,MAAM,OAAO,GAAU,CAAC,2NAoB5B,IAAI,CAAC,CAAC,CAAC,KAAG,OAAO,CAAC,IAAI,CA0hBxB,CAAA"}

package/dist/fields/hooks/beforeValidate/promise.js

@@ -0,0 +1,476 @@
+import { MissingEditorProp } from '../../../errors/index.js';
+import { fieldAffectsData, tabHasName, valueIsValueWithRelation } from '../../config/types.js';
+import { getFieldPaths } from '../../getFieldPaths.js';
+import { getExistingRowDoc } from '../beforeChange/getExistingRowDoc.js';
+import { getFallbackValue } from './getFallbackValue.js';
+import { traverseFields } from './traverseFields.js';
+// This function is responsible for the following actions, in order:
+// - Sanitize incoming data
+// - Execute field hooks
+// - Execute field access control
+// - Merge original document data into incoming data
+// - Compute default values for undefined fields
+export const promise = async ({ id, blockData, collection, context, data, doc, field, fieldIndex, global, operation, overrideAccess, parentIndexPath, parentIsLocalized, parentPath, parentSchemaPath, req, siblingData, siblingDoc, siblingFields })=>{
+    const { indexPath, path, schemaPath } = getFieldPaths({
+        field,
+        index: fieldIndex,
+        parentIndexPath,
+        parentPath,
+        parentSchemaPath
+    });
+    const pathSegments = path ? path.split('.') : [];
+    const schemaPathSegments = schemaPath ? schemaPath.split('.') : [];
+    const indexPathSegments = indexPath ? indexPath.split('-').filter(Boolean)?.map(Number) : [];
+    if (fieldAffectsData(field)) {
+        if (field.name === 'id') {
+            if (field.type === 'number' && typeof siblingData[field.name] === 'string') {
+                const value = siblingData[field.name];
+                siblingData[field.name] = parseFloat(value);
+            }
+            if (field.type === 'text' && typeof siblingData[field.name]?.toString === 'function' && typeof siblingData[field.name] !== 'string') {
+                siblingData[field.name] = siblingData[field.name].toString();
+            }
+        }
+        // Sanitize incoming data
+        switch(field.type){
+            case 'array':
+            case 'blocks':
+                {
+                    // Handle cases of arrays being intentionally set to 0
+                    if (siblingData[field.name] === '0' || siblingData[field.name] === 0) {
+                        siblingData[field.name] = [];
+                    }
+                    break;
+                }
+            case 'checkbox':
+                {
+                    if (siblingData[field.name] === 'true') {
+                        siblingData[field.name] = true;
+                    }
+                    if (siblingData[field.name] === 'false') {
+                        siblingData[field.name] = false;
+                    }
+                    if (siblingData[field.name] === '') {
+                        siblingData[field.name] = false;
+                    }
+                    break;
+                }
+            case 'number':
+                {
+                    if (typeof siblingData[field.name] === 'string') {
+                        const value = siblingData[field.name];
+                        const trimmed = value.trim();
+                        siblingData[field.name] = trimmed.length === 0 ? null : parseFloat(trimmed);
+                    }
+                    break;
+                }
+            case 'point':
+                {
+                    if (Array.isArray(siblingData[field.name])) {
+                        siblingData[field.name] = siblingData[field.name].map((coordinate, i)=>{
+                            if (typeof coordinate === 'string') {
+                                const value = siblingData[field.name][i];
+                                const trimmed = value.trim();
+                                return trimmed.length === 0 ? null : parseFloat(trimmed);
+                            }
+                            return coordinate;
+                        });
+                    }
+                    break;
+                }
+            case 'relationship':
+            case 'upload':
+                {
+                    if (siblingData[field.name] === '' || siblingData[field.name] === 'none' || siblingData[field.name] === 'null' || siblingData[field.name] === null) {
+                        if (field.hasMany === true) {
+                            siblingData[field.name] = [];
+                        } else {
+                            siblingData[field.name] = null;
+                        }
+                    }
+                    const value = siblingData[field.name];
+                    if (Array.isArray(field.relationTo)) {
+                        if (Array.isArray(value)) {
+                            value.forEach((relatedDoc, i)=>{
+                                const relatedCollection = req.payload.collections?.[relatedDoc.relationTo]?.config;
+                                if (typeof relatedDoc.value === 'object' && relatedDoc.value && 'id' in relatedDoc.value) {
+                                    relatedDoc.value = relatedDoc.value.id;
+                                }
+                                if (relatedCollection?.fields) {
+                                    const relationshipIDField = relatedCollection.fields.find((collectionField)=>fieldAffectsData(collectionField) && collectionField.name === 'id');
+                                    if (relationshipIDField?.type === 'number') {
+                                        siblingData[field.name][i] = {
+                                            ...relatedDoc,
+                                            value: parseFloat(relatedDoc.value)
+                                        };
+                                    }
+                                }
+                            });
+                        }
+                        if (field.hasMany !== true && valueIsValueWithRelation(value)) {
+                            const relatedCollection = req.payload.collections?.[value.relationTo]?.config;
+                            if (typeof value.value === 'object' && value.value && 'id' in value.value) {
+                                value.value = value.value.id;
+                            }
+                            if (relatedCollection?.fields) {
+                                const relationshipIDField = relatedCollection.fields.find((collectionField)=>fieldAffectsData(collectionField) && collectionField.name === 'id');
+                                if (relationshipIDField?.type === 'number') {
+                                    siblingData[field.name] = {
+                                        ...value,
+                                        value: parseFloat(value.value)
+                                    };
+                                }
+                            }
+                        }
+                    } else {
+                        if (Array.isArray(value)) {
+                            value.forEach((relatedDoc, i)=>{
+                                const relatedCollection = Array.isArray(field.relationTo) ? undefined : req.payload.collections?.[field.relationTo]?.config;
+                                if (typeof relatedDoc === 'object' && relatedDoc && 'id' in relatedDoc) {
+                                    value[i] = relatedDoc.id;
+                                }
+                                if (relatedCollection?.fields) {
+                                    const relationshipIDField = relatedCollection.fields.find((collectionField)=>fieldAffectsData(collectionField) && collectionField.name === 'id');
+                                    if (relationshipIDField?.type === 'number') {
+                                        siblingData[field.name][i] = parseFloat(relatedDoc);
+                                    }
+                                }
+                            });
+                        }
+                        if (field.hasMany !== true && value) {
+                            const relatedCollection = req.payload.collections?.[field.relationTo]?.config;
+                            if (typeof value === 'object' && value && 'id' in value) {
+                                siblingData[field.name] = value.id;
+                            }
+                            if (relatedCollection?.fields) {
+                                const relationshipIDField = relatedCollection.fields.find((collectionField)=>fieldAffectsData(collectionField) && collectionField.name === 'id');
+                                if (relationshipIDField?.type === 'number') {
+                                    siblingData[field.name] = parseFloat(value);
+                                }
+                            }
+                        }
+                    }
+                    break;
+                }
+            case 'richText':
+                {
+                    if (typeof siblingData[field.name] === 'string') {
+                        try {
+                            const richTextJSON = JSON.parse(siblingData[field.name]);
+                            siblingData[field.name] = richTextJSON;
+                        } catch  {
+                        // Disregard this data as it is not valid.
+                        // Will be reported to user by field validation
+                        }
+                    }
+                    break;
+                }
+            default:
+                {
+                    break;
+                }
+        }
+        // ensure the fallback value is only computed one time
+        // either here or when access control returns false
+        const fallbackResult = {
+            executed: false,
+            value: undefined
+        };
+        if (typeof siblingData[field.name] === 'undefined') {
+            fallbackResult.value = await getFallbackValue({
+                field,
+                req,
+                siblingDoc
+            });
+            fallbackResult.executed = true;
+        }
+        // Execute hooks
+        if ('hooks' in field && field.hooks?.beforeValidate) {
+            for (const hook of field.hooks.beforeValidate){
+                const hookedValue = await hook({
+                    blockData,
+                    collection,
+                    context,
+                    data: data,
+                    field,
+                    global,
+                    indexPath: indexPathSegments,
+                    operation,
+                    originalDoc: doc,
+                    overrideAccess,
+                    path: pathSegments,
+                    previousSiblingDoc: siblingDoc,
+                    previousValue: siblingDoc[field.name],
+                    req,
+                    schemaPath: schemaPathSegments,
+                    siblingData,
+                    siblingFields: siblingFields,
+                    value: typeof siblingData[field.name] === 'undefined' ? fallbackResult.value : siblingData[field.name]
+                });
+                if (hookedValue !== undefined) {
+                    siblingData[field.name] = hookedValue;
+                }
+            }
+        }
+        // Execute access control
+        if (field.access && field.access[operation]) {
+            const result = overrideAccess ? true : await field.access[operation]({
+                id,
+                blockData,
+                data: data,
+                doc,
+                req,
+                siblingData
+            });
+            if (!result) {
+                delete siblingData[field.name];
+            }
+        }
+        if (typeof siblingData[field.name] === 'undefined') {
+            siblingData[field.name] = !fallbackResult.executed ? await getFallbackValue({
+                field,
+                req,
+                siblingDoc
+            }) : fallbackResult.value;
+        }
+    }
+    // Traverse subfields
+    switch(field.type){
+        case 'array':
+            {
+                const rows = siblingData[field.name];
+                if (Array.isArray(rows)) {
+                    const promises = [];
+                    rows.forEach((row, rowIndex)=>{
+                        promises.push(traverseFields({
+                            id,
+                            blockData,
+                            collection,
+                            context,
+                            data,
+                            doc,
+                            fields: field.fields,
+                            global,
+                            operation,
+                            overrideAccess,
+                            parentIndexPath: '',
+                            parentIsLocalized: parentIsLocalized || field.localized,
+                            parentPath: path + '.' + rowIndex,
+                            parentSchemaPath: schemaPath,
+                            req,
+                            siblingData: row,
+                            siblingDoc: getExistingRowDoc(row, siblingDoc[field.name])
+                        }));
+                    });
+                    await Promise.all(promises);
+                }
+                break;
+            }
+        case 'blocks':
+            {
+                const rows = siblingData[field.name];
+                if (Array.isArray(rows)) {
+                    const promises = [];
+                    rows.forEach((row, rowIndex)=>{
+                        const rowSiblingDoc = getExistingRowDoc(row, siblingDoc[field.name]);
+                        const blockTypeToMatch = row.blockType || rowSiblingDoc.blockType;
+                        const block = req.payload.blocks[blockTypeToMatch] ?? (field.blockReferences ?? field.blocks).find((curBlock)=>typeof curBlock !== 'string' && curBlock.slug === blockTypeToMatch);
+                        if (block) {
+                            ;
+                            row.blockType = blockTypeToMatch;
+                            promises.push(traverseFields({
+                                id,
+                                blockData: row,
+                                collection,
+                                context,
+                                data,
+                                doc,
+                                fields: block.fields,
+                                global,
+                                operation,
+                                overrideAccess,
+                                parentIndexPath: '',
+                                parentIsLocalized: parentIsLocalized || field.localized,
+                                parentPath: path + '.' + rowIndex,
+                                parentSchemaPath: schemaPath + '.' + block.slug,
+                                req,
+                                siblingData: row,
+                                siblingDoc: rowSiblingDoc
+                            }));
+                        }
+                    });
+                    await Promise.all(promises);
+                }
+                break;
+            }
+        case 'collapsible':
+        case 'row':
+            {
+                await traverseFields({
+                    id,
+                    blockData,
+                    collection,
+                    context,
+                    data,
+                    doc,
+                    fields: field.fields,
+                    global,
+                    operation,
+                    overrideAccess,
+                    parentIndexPath: indexPath,
+                    parentIsLocalized,
+                    parentPath,
+                    parentSchemaPath: schemaPath,
+                    req,
+                    siblingData,
+                    siblingDoc
+                });
+                break;
+            }
+        case 'group':
+            {
+                let groupSiblingData = siblingData;
+                let groupSiblingDoc = siblingDoc;
+                const isNamedGroup = fieldAffectsData(field);
+                if (isNamedGroup) {
+                    if (typeof siblingData[field.name] !== 'object') {
+                        siblingData[field.name] = {};
+                    }
+                    if (typeof siblingDoc[field.name] !== 'object') {
+                        siblingDoc[field.name] = {};
+                    }
+                    groupSiblingData = siblingData[field.name];
+                    groupSiblingDoc = siblingDoc[field.name];
+                }
+                await traverseFields({
+                    id,
+                    blockData,
+                    collection,
+                    context,
+                    data,
+                    doc,
+                    fields: field.fields,
+                    global,
+                    operation,
+                    overrideAccess,
+                    parentIndexPath: isNamedGroup ? '' : indexPath,
+                    parentIsLocalized: parentIsLocalized || field.localized,
+                    parentPath: isNamedGroup ? path : parentPath,
+                    parentSchemaPath: schemaPath,
+                    req,
+                    siblingData: groupSiblingData,
+                    siblingDoc: groupSiblingDoc
+                });
+                break;
+            }
+        case 'richText':
+            {
+                if (!field?.editor) {
+                    throw new MissingEditorProp(field) // while we allow disabling editor functionality, you should not have any richText fields defined if you do not have an editor
+                    ;
+                }
+                if (typeof field?.editor === 'function') {
+                    throw new Error('Attempted to access unsanitized rich text editor.');
+                }
+                const editor = field?.editor;
+                if (editor?.hooks?.beforeValidate?.length) {
+                    for (const hook of editor.hooks.beforeValidate){
+                        const hookedValue = await hook({
+                            collection,
+                            context,
+                            data: data,
+                            field,
+                            global,
+                            indexPath: indexPathSegments,
+                            operation,
+                            originalDoc: doc,
+                            overrideAccess,
+                            parentIsLocalized,
+                            path: pathSegments,
+                            previousSiblingDoc: siblingDoc,
+                            previousValue: siblingData[field.name],
+                            req,
+                            schemaPath: schemaPathSegments,
+                            siblingData,
+                            value: siblingData[field.name]
+                        });
+                        if (hookedValue !== undefined) {
+                            siblingData[field.name] = hookedValue;
+                        }
+                    }
+                }
+                break;
+            }
+        case 'tab':
+            {
+                let tabSiblingData;
+                let tabSiblingDoc;
+                const isNamedTab = tabHasName(field);
+                if (isNamedTab) {
+                    if (typeof siblingData[field.name] !== 'object') {
+                        siblingData[field.name] = {};
+                    }
+                    if (typeof siblingDoc[field.name] !== 'object') {
+                        siblingDoc[field.name] = {};
+                    }
+                    tabSiblingData = siblingData[field.name];
+                    tabSiblingDoc = siblingDoc[field.name];
+                } else {
+                    tabSiblingData = siblingData;
+                    tabSiblingDoc = siblingDoc;
+                }
+                await traverseFields({
+                    id,
+                    blockData,
+                    collection,
+                    context,
+                    data,
+                    doc,
+                    fields: field.fields,
+                    global,
+                    operation,
+                    overrideAccess,
+                    parentIndexPath: isNamedTab ? '' : indexPath,
+                    parentIsLocalized: parentIsLocalized || field.localized,
+                    parentPath: isNamedTab ? path : parentPath,
+                    parentSchemaPath: schemaPath,
+                    req,
+                    siblingData: tabSiblingData,
+                    siblingDoc: tabSiblingDoc
+                });
+                break;
+            }
+        case 'tabs':
+            {
+                await traverseFields({
+                    id,
+                    blockData,
+                    collection,
+                    context,
+                    data,
+                    doc,
+                    fields: field.tabs.map((tab)=>({
+                            ...tab,
+                            type: 'tab'
+                        })),
+                    global,
+                    operation,
+                    overrideAccess,
+                    parentIndexPath: indexPath,
+                    parentIsLocalized,
+                    parentPath: path,
+                    parentSchemaPath: schemaPath,
+                    req,
+                    siblingData,
+                    siblingDoc
+                });
+                break;
+            }
+        default:
+            {
+                break;
+            }
+    }
+};
+
+//# sourceMappingURL=promise.js.map