@payloadcms/figma 0.0.1-alpha.9 → 0.1.0-alpha.1

package/dist/db-content-api/utilities/data/convertRelationshipIds.js

@@ -0,0 +1,109 @@
+import { valueIsValueWithRelation } from 'payload/shared';
+import { matchAtomicOperation, RELATIONSHIP_ATOMIC_OPERATORS } from './atomicOperations.js';
+import { isLocaleMap } from './isLocaleMap.js';
+export function convertRelationshipFieldIdsFromWire(options) {
+    return convertRelationshipFieldIds({
+        ...options,
+        direction: 'fromWire'
+    });
+}
+export function convertRelationshipFieldIdsToWire(options) {
+    return convertRelationshipFieldIds({
+        ...options,
+        direction: 'toWire'
+    });
+}
+/**
+ * Converts the id(s) inside a relationship/upload field value between Payload's
+ * representation (numeric ids kept as numbers) and the Content API wire form
+ * (all ids as strings). No-op for uuid/text targets. Preserves has-many arrays,
+ * polymorphic shapes, localized locale-maps, and atomic operators.
+ */ export function convertRelationshipFieldIds(options) {
+    const { direction, field, payload, value } = options;
+    if (value == null) {
+        return value;
+    }
+    const relationTo = field.relationTo;
+    const localized = field.localized ?? false;
+    const hasMany = field.hasMany ?? false;
+    // The value shape is fully determined by the localized × hasMany combination:
+    //   !localized, !hasMany → a single value
+    //   !localized,  hasMany → an array of values (or a `$push`/`$remove` wrapper)
+    //    localized, !hasMany → a locale-map of single values
+    //    localized,  hasMany → a locale-map of arrays
+    // Localized values arrive as a locale-map on write and all-locales reads, but
+    // as the bare per-locale value on single-locale reads, so a localized field
+    // dispatches through `convertLocalized`, which handles both.
+    const convertValue = (entry)=>hasMany ? convertHasManyValue(entry, relationTo, payload, direction) : convertSingleValue(entry, relationTo, payload, direction);
+    return localized ? convertLocalized(value, convertValue) : convertValue(value);
+}
+// Applies `convertValue` to each entry of a localized locale-map. A single-locale
+// read delivers the bare per-locale value instead of a map (a plain object then
+// is a polymorphic ref, not a locale-map), so that case is converted directly.
+function convertLocalized(value, convertValue) {
+    if (!isLocaleMap(value)) {
+        return convertValue(value);
+    }
+    const out = {};
+    for (const [locale, localeValue] of Object.entries(value)){
+        out[locale] = localeValue == null ? localeValue : convertValue(localeValue);
+    }
+    return out;
+}
+// A has-many value normalizes to an array of single values: Payload may pass a
+// lone value (e.g. `children: 'uuid'`), which is wrapped into a single-element
+// array. Writes may instead wrap the value in an atomic `$push`/`$remove`
+// operator, which is preserved — its payload is converted but not array-wrapped,
+// since those operators accept a single value or an array.
+function convertHasManyValue(value, relationTo, payload, direction) {
+    const atomic = matchAtomicOperation(value, RELATIONSHIP_ATOMIC_OPERATORS);
+    if (atomic) {
+        return {
+            [atomic.operator]: convertAtomicPayload(atomic.inner, relationTo, payload, direction)
+        };
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry)=>convertSingleValue(entry, relationTo, payload, direction));
+    }
+    return [
+        convertSingleValue(value, relationTo, payload, direction)
+    ];
+}
+// The payload of a `$push`/`$remove` operator may be a single value or an array;
+// convert either without changing its arity.
+function convertAtomicPayload(value, relationTo, payload, direction) {
+    return Array.isArray(value) ? value.map((entry)=>convertSingleValue(entry, relationTo, payload, direction)) : convertSingleValue(value, relationTo, payload, direction);
+}
+// A single relationship value is a polymorphic `{ relationTo, value }` (when the
+// field targets multiple collections) or a bare id (when it targets one). The id
+// type comes from the referenced collection.
+function convertSingleValue(value, relationTo, payload, direction) {
+    if (value == null) {
+        return value;
+    }
+    if (valueIsValueWithRelation(value)) {
+        return {
+            ...value,
+            value: convertLeafId(value.value, customIdTypeFor(payload, value.relationTo), direction)
+        };
+    }
+    // A non-polymorphic field targets a single collection (string `relationTo`).
+    const customIDType = typeof relationTo === 'string' ? customIdTypeFor(payload, relationTo) : undefined;
+    return convertLeafId(value, customIDType, direction);
+}
+function customIdTypeFor(payload, slug) {
+    return payload.collections?.[slug]?.customIDType;
+}
+function convertLeafId(id, customIDType, direction) {
+    if (id == null || id === '') {
+        return id;
+    }
+    // Only numeric custom ids differ between Payload (number) and the wire (string).
+    if (customIDType !== 'number') {
+        return id;
+    }
+    if (direction === 'toWire') {
+        return typeof id === 'number' ? String(id) : id;
+    }
+    return typeof id === 'string' ? Number(id) : id;
+}

package/dist/db-content-api/utilities/data/index.d.ts

@@ -0,0 +1,48 @@
+import type { Payload } from 'payload';
+import type { components } from '../../generated/content-api-types.js';
+type DataWithOperations = components['schemas']['DataWithOperations'];
+interface DataToContentAPIOptions {
+    /** Apply static defaults for undefined fields */
+    applyDefaults?: boolean;
+    /** Add createdAt timestamp */
+    createdAt?: boolean;
+    /**
+     * Transform publishedLocale to localizeStatus format.
+     * When provided, converts `_status: 'published'` + `publishedLocale: 'en'`
+     * to `_status: { en: 'published' }` format.
+     */
+    publishedLocale?: string;
+}
+/**
+ * Transform data before sending to Content API (WRITE operations)
+ *
+ * Conversions applied:
+ * - Default values: Apply static defaults for undefined fields (when applyDefaults=true)
+ * - Type casting: Convert values to match field types (e.g., number -> string for text fields)
+ * - RichText fields: Objects -> JSON strings
+ * - Virtual fields: Remove fields with `virtual: true` (pure virtual fields should never be saved)
+ * - Timestamps: Add updatedAt (always), and createdAt (when createdAt=true)
+ * - publishedLocale: Transform to localizeStatus format (when publishedLocale is provided)
+ *
+ * Note: Date fields are automatically converted to ISO strings by JSON.stringify()
+ */
+export declare function dataToContentAPI(payload: Payload, collectionSlug: string, data: unknown, options?: DataToContentAPIOptions): DataWithOperations;
+/**
+ * Transform data received from Content API (READ operations)
+ *
+ * Conversions applied:
+ * - RichText fields: JSON strings -> Objects
+ * - Virtual fields: Remove fields with `virtual: true` (should not be in DB but Content API backend may add them)
+ *
+ * Note: Date fields come as ISO strings from Content API and stay as strings
+ * (matching MongoDB and other adapters' behavior)
+ */
+/**
+ * Extract version content from versionData that may be flat (no nested `version` key).
+ * Some callers spread version content at the top level alongside metadata
+ * (e.g. `{ ...version.version, createdAt }`), so we reconstruct the `version`
+ * object by filtering out known metadata keys.
+ */
+export declare function resolveVersionContent(version: unknown, versionMeta: Record<string, unknown>): unknown;
+export declare function dataFromContentAPI(payload: Payload, collectionSlug: string, data: unknown, locale?: string): unknown;
+export {};

package/dist/db-content-api/utilities/data/index.js

@@ -0,0 +1,315 @@
+import { flattenAllFields, traverseFields } from 'payload';
+import { applyDefaults } from './applyDefaults.js';
+import { ATOMIC_OPERATORS, isAtomicOperation } from './atomicOperations.js';
+import { castFieldValue } from './castFieldValue.js';
+import { convertRelationshipFieldIds } from './convertRelationshipIds.js';
+import { decodePointFromRead, encodePointForWrite } from './pointShape.js';
+import { removeVirtualFields } from './removeVirtualFields.js';
+import { resolveFieldLocalization } from './resolveFieldLocalization.js';
+import { decodeRichTextFromRead, encodeRichTextForWrite } from './richTextShape.js';
+import { stripFields } from './stripFields.js';
+import { transformToLocalizeStatus } from './transformPublishedLocale.js';
+/**
+ * Transform data before sending to Content API (WRITE operations)
+ *
+ * Conversions applied:
+ * - Default values: Apply static defaults for undefined fields (when applyDefaults=true)
+ * - Type casting: Convert values to match field types (e.g., number -> string for text fields)
+ * - RichText fields: Objects -> JSON strings
+ * - Virtual fields: Remove fields with `virtual: true` (pure virtual fields should never be saved)
+ * - Timestamps: Add updatedAt (always), and createdAt (when createdAt=true)
+ * - publishedLocale: Transform to localizeStatus format (when publishedLocale is provided)
+ *
+ * Note: Date fields are automatically converted to ISO strings by JSON.stringify()
+ */ export function dataToContentAPI(payload, collectionSlug, data, options) {
+    if (!data || typeof data !== 'object') {
+        return data;
+    }
+    // Transform publishedLocale to localizeStatus format before other transformations
+    const dataWithLocalizedStatus = transformToLocalizeStatus(data, options?.publishedLocale);
+    // Deep clone to avoid mutating original data
+    const transformed = JSON.parse(JSON.stringify(dataWithLocalizedStatus));
+    // Get collection config
+    const isGlobal = collectionSlug.startsWith('_global-');
+    const actualSlug = isGlobal ? collectionSlug.substring(8) : collectionSlug;
+    const collectionConfig = isGlobal ? payload.config.globals?.find((g)=>g.slug === actualSlug) : payload.config.collections.find((c)=>c.slug === actualSlug);
+    if (!collectionConfig?.fields) {
+        return transformed;
+    }
+    // Apply static defaults recursively to handle nested structures (arrays, groups)
+    // This must happen before traverseFields to ensure defaults are in place
+    if (options?.applyDefaults) {
+        applyDefaults(transformed, collectionConfig.fields, payload.config.blocks);
+    }
+    // Use Payload's traverseFields to iterate over all fields for transformations
+    const callback = ({ field: declaredField, parentIsLocalized, ref })=>{
+        if (!('name' in declaredField) || declaredField.name == null) {
+            return;
+        }
+        if (!ref || typeof ref !== 'object') {
+            return;
+        }
+        const fieldName = declaredField.name;
+        const field = resolveFieldLocalization({
+            field: declaredField,
+            isAbsorbed: parentIsLocalized
+        });
+        const current = ref;
+        let value = current[fieldName];
+        if (isAtomicOperation(value, ATOMIC_OPERATORS) && field.type !== 'relationship' && field.type !== 'upload') {
+            return;
+        }
+        // null → [] for non-localized array-like fields. SQL adapters return null for empty join
+        // tables; Content API stores JSON null which breaks jsonb_array_elements queries.
+        if (value === null && !('localized' in field && field.localized)) {
+            const isHasManyArray = (field.type === 'relationship' || field.type === 'upload') && 'hasMany' in field && field.hasMany;
+            const isArrayLike = field.type === 'array' || field.type === 'blocks';
+            const isHasManySelect = field.type === 'select' && 'hasMany' in field && field.hasMany;
+            if (isHasManyArray || isArrayLike || isHasManySelect) {
+                current[fieldName] = [];
+                return;
+            }
+        }
+        if (value !== null && value !== undefined) {
+            if (field.type === 'relationship' || field.type === 'upload') {
+                // Convert ids that point at a numeric-custom-id collection to strings —
+                // the wire (and the server's relationshipSchema) only accepts string ids —
+                // and normalize a has-many value to an array.
+                current[fieldName] = convertRelationshipFieldIds({
+                    direction: 'toWire',
+                    field,
+                    payload,
+                    value
+                });
+                return;
+            }
+            if (field.type === 'point') {
+                current[fieldName] = encodePointForWrite(field, value);
+                return;
+            }
+            if (field.type === 'richText') {
+                current[fieldName] = encodeRichTextForWrite(field, value);
+                return;
+            }
+            value = castFieldValue(field, value);
+            current[fieldName] = value;
+        }
+    };
+    traverseFields({
+        callback,
+        fields: collectionConfig.fields,
+        fillEmpty: false,
+        ref: transformed
+    });
+    stripFields({
+        config: payload.config,
+        data: transformed,
+        fields: flattenAllFields({
+            cache: true,
+            fields: collectionConfig.fields
+        }),
+        reservedKeys: [
+            'id'
+        ]
+    });
+    removeVirtualFields(transformed, collectionConfig.fields);
+    // Convert numeric ID to string for Content API
+    const customIDType = payload.collections?.[collectionSlug]?.customIDType;
+    if (customIDType === 'number') {
+        transformed.id = String(transformed.id);
+    }
+    // Add timestamps (Content API no longer auto-sets these in DB)
+    // Preserve existing timestamps when already present (e.g. version data that carries
+    // the parent document's timestamps), otherwise generate new ones.
+    // Explicit null means "don't change" — strip it so the API keeps the existing value.
+    const now = new Date().toISOString();
+    if (transformed.updatedAt === null) {
+        delete transformed.updatedAt;
+    } else if (transformed.updatedAt === undefined) {
+        transformed.updatedAt = now;
+    }
+    if (options?.createdAt && !transformed.createdAt) {
+        transformed.createdAt = now;
+    }
+    return transformed;
+}
+/**
+ * Transform data received from Content API (READ operations)
+ *
+ * Conversions applied:
+ * - RichText fields: JSON strings -> Objects
+ * - Virtual fields: Remove fields with `virtual: true` (should not be in DB but Content API backend may add them)
+ *
+ * Note: Date fields come as ISO strings from Content API and stay as strings
+ * (matching MongoDB and other adapters' behavior)
+ */ /**
+ * Extract version content from versionData that may be flat (no nested `version` key).
+ * Some callers spread version content at the top level alongside metadata
+ * (e.g. `{ ...version.version, createdAt }`), so we reconstruct the `version`
+ * object by filtering out known metadata keys.
+ */ export function resolveVersionContent(version, versionMeta) {
+    if (version !== undefined) {
+        return version;
+    }
+    const metaKeys = [
+        'createdAt',
+        'updatedAt',
+        'latest',
+        'parent'
+    ];
+    return Object.fromEntries(Object.entries(versionMeta).filter(([key])=>!metaKeys.includes(key)));
+}
+export function dataFromContentAPI(payload, collectionSlug, data, locale) {
+    if (!data || typeof data !== 'object') {
+        return data;
+    }
+    // Deep clone to avoid mutating original data
+    const transformed = JSON.parse(JSON.stringify(data));
+    // Get collection config
+    const isGlobal = collectionSlug.startsWith('_global-');
+    const actualSlug = isGlobal ? collectionSlug.substring(8) : collectionSlug;
+    const collectionConfig = isGlobal ? payload.config.globals?.find((g)=>g.slug === actualSlug) : payload.config.collections.find((c)=>c.slug === actualSlug);
+    if (!collectionConfig?.fields) {
+        return transformed;
+    }
+    const isAllLocales = locale === 'all' || locale === '*';
+    // Use Payload's traverseFields to iterate over all fields
+    const callback = ({ field: declaredField, parentIsLocalized, parentPath, ref })=>{
+        if (!('name' in declaredField) || !declaredField.name) {
+            return;
+        }
+        if (!ref || typeof ref !== 'object') {
+            return;
+        }
+        // Value shaping below depends on whether locale keys appear at this path, so
+        // work from the resolved field rather than the declared one.
+        const fieldName = declaredField.name;
+        const field = resolveFieldLocalization({
+            field: declaredField,
+            isAbsorbed: parentIsLocalized
+        });
+        const current = ref;
+        const value = current[fieldName];
+        const isLocalized = 'localized' in field && field.localized === true;
+        // Group fields must always be an object so Payload can traverse sub-fields
+        // (e.g. join fields inside a group). A null/undefined group crashes afterRead.
+        if (field.type === 'group') {
+            if (value == null || typeof value !== 'object') {
+                current[fieldName] = {};
+            }
+            return;
+        }
+        // Localized join fields: wrap in locale map so afterRead can hoist the value.
+        // Content API returns join data directly at the field path (e.g. { docs: [...] }),
+        // but Payload's afterRead expects localized fields as { [locale]: value }.
+        if (field.type === 'join' && isLocalized && value !== undefined && !isAllLocales && locale) {
+            current[fieldName] = {
+                [locale]: value
+            };
+            return;
+        }
+        // Content API may omit fields; Payload expects null for optional fields.
+        // In all-locales mode, localized fields use {} so afterRead can safely iterate locale keys.
+        if (value === undefined) {
+            const isRequired = 'required' in field && field.required;
+            const isJoin = field.type === 'join';
+            if (!isRequired && !isJoin) {
+                current[fieldName] = isLocalized && isAllLocales ? {} : null;
+            }
+            return;
+        }
+        // null localized field in all-locales mode → {} (empty locale map)
+        if (value === null && isLocalized && isAllLocales) {
+            current[fieldName] = {};
+            return;
+        }
+        if (value !== null) {
+            if (field.type === 'relationship' || field.type === 'upload') {
+                // The Content API returns ids as strings; convert back to numbers for
+                // relationships that point at a numeric-custom-id collection so Payload
+                // sees its native type, and normalize a has-many value to an array.
+                current[fieldName] = convertRelationshipFieldIds({
+                    direction: 'fromWire',
+                    field,
+                    payload,
+                    value
+                });
+                return;
+            }
+            if (field.type === 'point') {
+                current[fieldName] = decodePointFromRead(field, value);
+                return;
+            }
+            if (field.type === 'richText') {
+                const fieldPath = parentPath ? `${parentPath}.${field.name}` : field.name;
+                current[fieldName] = decodeRichTextFromRead(field, value, payload, fieldPath, collectionSlug);
+                return;
+            }
+            // Localized array/blocks: empty per-locale arrays → null in single-locale mode.
+            // Payload's afterRead fallback triggers on null (not []), matching SQL adapter behavior.
+            if (isLocalized && !isAllLocales && (field.type === 'array' || field.type === 'blocks') && typeof value === 'object' && !Array.isArray(value)) {
+                const localeMap = value;
+                for (const localeKey of Object.keys(localeMap)){
+                    const localeValue = localeMap[localeKey];
+                    if (Array.isArray(localeValue) && localeValue.length === 0) {
+                        localeMap[localeKey] = null;
+                    }
+                }
+            }
+            // Localized fields: JSON string → parsed object (locale map).
+            // Simple strings that fail to parse as objects are kept as-is (expected for single-locale).
+            if (isLocalized && typeof value === 'string') {
+                try {
+                    const parsed = JSON.parse(value);
+                    if (typeof parsed === 'object' && parsed !== null) {
+                        current[fieldName] = parsed;
+                    }
+                } catch  {
+                // Not valid JSON - keep original value
+                }
+            }
+        // Date fields: Already ISO strings from Content API, no conversion needed
+        }
+    };
+    traverseFields({
+        callback,
+        fields: collectionConfig.fields,
+        fillEmpty: false,
+        ref: transformed
+    });
+    // Convert string ID to number if collection uses numeric custom ID
+    const customIDType = payload.collections?.[collectionSlug]?.customIDType;
+    if (customIDType === 'number') {
+        transformed.id = Number(transformed.id);
+    }
+    stripFields({
+        config: payload.config,
+        data: transformed,
+        fields: flattenAllFields({
+            cache: true,
+            fields: collectionConfig.fields
+        }),
+        reservedKeys: [
+            'id',
+            'globalType'
+        ]
+    });
+    // Remove virtual fields - must happen AFTER stripFields
+    removeVirtualFields(transformed, collectionConfig.fields);
+    // Handle auth-specific fields that aren't in the field schema
+    // When these fields are null in DB, Content API omits them from response (undefined)
+    // But Payload expects them to be null, not undefined
+    // Only add them if the collection has auth enabled
+    if ('auth' in collectionConfig && collectionConfig.auth) {
+        const authFields = [
+            'resetPasswordExpiration',
+            'lockUntil'
+        ];
+        for (const fieldName of authFields){
+            if (!(fieldName in transformed)) {
+                transformed[fieldName] = null;
+            }
+        }
+    }
+    return transformed;
+}

package/dist/db-content-api/utilities/data/isLocaleMap.d.ts

@@ -0,0 +1,10 @@
+/**
+ * A locale-map is a plain object keyed by locale (e.g. `{ en: 'id', fr: 'id' }`) —
+ * distinct from the other object shapes a field value can take: a polymorphic
+ * relationship ref (`{ relationTo, value }`) or an atomic wrapper (`{ $push: … }`).
+ *
+ * Localized values arrive as a locale-map on write and all-locales reads, but as
+ * the bare per-locale value on single-locale reads, so a localized field cannot
+ * assume the map and has to discriminate on the shape.
+ */
+export declare function isLocaleMap(value: unknown): value is Record<string, unknown>;

package/dist/db-content-api/utilities/data/isLocaleMap.js

@@ -0,0 +1,13 @@
+import { valueIsValueWithRelation } from 'payload/shared';
+import { ATOMIC_OPERATORS, isAtomicOperation } from './atomicOperations.js';
+/**
+ * A locale-map is a plain object keyed by locale (e.g. `{ en: 'id', fr: 'id' }`) —
+ * distinct from the other object shapes a field value can take: a polymorphic
+ * relationship ref (`{ relationTo, value }`) or an atomic wrapper (`{ $push: … }`).
+ *
+ * Localized values arrive as a locale-map on write and all-locales reads, but as
+ * the bare per-locale value on single-locale reads, so a localized field cannot
+ * assume the map and has to discriminate on the shape.
+ */ export function isLocaleMap(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value) && !valueIsValueWithRelation(value) && !isAtomicOperation(value, ATOMIC_OPERATORS);
+}

package/dist/db-content-api/utilities/data/pointShape.d.ts

@@ -0,0 +1,3 @@
+import type { Field, TabAsField } from 'payload';
+export declare function encodePointForWrite(field: Field | TabAsField, value: unknown): unknown;
+export declare function decodePointFromRead(field: Field | TabAsField, value: unknown): unknown;

package/dist/db-content-api/utilities/data/pointShape.js

@@ -0,0 +1,43 @@
+/**
+ * Payload stores a point as GeoJSON; the v1 server uses a bare `[lng, lat]`
+ * tuple. Unwrap on write, re-wrap on read so afterRead can restore the tuple.
+ */ function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isCoordinateTuple(value) {
+    return Array.isArray(value) && value.length === 2 && value.every((v)=>typeof v === 'number');
+}
+function pointLeafToWire(value) {
+    if (isPlainObject(value) && isCoordinateTuple(value.coordinates)) {
+        return value.coordinates;
+    }
+    return value;
+}
+function pointLeafFromWire(value) {
+    if (isCoordinateTuple(value)) {
+        return {
+            type: 'Point',
+            coordinates: value
+        };
+    }
+    return value;
+}
+function mapPoint(field, value, mapLeaf) {
+    if (field.type !== 'point' || value === null || value === undefined) {
+        return value;
+    }
+    if ('localized' in field && field.localized && isPlainObject(value)) {
+        const result = {};
+        for (const [locale, localeValue] of Object.entries(value)){
+            result[locale] = mapLeaf(localeValue);
+        }
+        return result;
+    }
+    return mapLeaf(value);
+}
+export function encodePointForWrite(field, value) {
+    return mapPoint(field, value, pointLeafToWire);
+}
+export function decodePointFromRead(field, value) {
+    return mapPoint(field, value, pointLeafFromWire);
+}

package/dist/db-content-api/utilities/data/removeVirtualFields.d.ts

@@ -0,0 +1,11 @@
+import type { CollectionConfig } from 'payload';
+/**
+ * Removes virtual fields (fields with virtual: true) from data recursively.
+ * Virtual fields should never be persisted in the database.
+ *
+ * @todo It might be a good idea to combine `stripFields` with `stripFields`
+ *  in a new utility that receives a callback with conditions. I didn't do
+ * it now because `stripFields` was copied from db-mongo and I'd like to
+ * find a way to unify everything.
+ */
+export declare function removeVirtualFields(data: Record<string, unknown>, fieldConfigs: CollectionConfig['fields']): void;

package/dist/db-content-api/utilities/data/removeVirtualFields.js

@@ -0,0 +1,52 @@
+/**
+ * Removes virtual fields (fields with virtual: true) from data recursively.
+ * Virtual fields should never be persisted in the database.
+ *
+ * @todo It might be a good idea to combine `stripFields` with `stripFields`
+ *  in a new utility that receives a callback with conditions. I didn't do
+ * it now because `stripFields` was copied from db-mongo and I'd like to
+ * find a way to unify everything.
+ */ export function removeVirtualFields(data, fieldConfigs) {
+    for (const field of fieldConfigs){
+        // Handle UI fields (row, collapsible, tabs) - they don't have names
+        // but contain other fields that might be virtual
+        if (field.type === 'row' || field.type === 'collapsible') {
+            if ('fields' in field) {
+                removeVirtualFields(data, field.fields);
+            }
+            continue;
+        }
+        if (field.type === 'tabs' && 'tabs' in field) {
+            for (const tab of field.tabs){
+                if ('fields' in tab) {
+                    removeVirtualFields(data, tab.fields);
+                }
+            }
+            continue;
+        }
+        // Skip fields without names
+        if (!('name' in field) || !field.name) {
+            continue;
+        }
+        // Remove field if it has virtual: true
+        if ('virtual' in field && field.virtual === true) {
+            delete data[field.name];
+            continue;
+        }
+        // Recursively handle nested structures (groups, arrays with items, etc.)
+        if ('fields' in field && field.name in data) {
+            const value = data[field.name];
+            if (field.type === 'array' && Array.isArray(value)) {
+                // Process each array item
+                for (const item of value){
+                    if (item && typeof item === 'object') {
+                        removeVirtualFields(item, field.fields);
+                    }
+                }
+            } else if (field.type === 'group' && value && typeof value === 'object') {
+                // Process group
+                removeVirtualFields(value, field.fields);
+            }
+        }
+    }
+}

package/dist/db-content-api/utilities/data/resolveFieldLocalization.d.ts

@@ -0,0 +1,18 @@
+import type { Field, TabAsField } from 'payload';
+interface ResolveFieldLocalizationOptions<TField extends Field | TabAsField> {
+    field: TField;
+    isAbsorbed: boolean;
+}
+/**
+ * Returns the field with `localized` collapsed to whether locale keys actually
+ * appear in its data — `false` for a field whose localized ancestor already
+ * absorbed them (see `createIsLocaleAbsorbed`).
+ *
+ * Every value-shaping helper keys off `field.localized` to decide whether it is
+ * looking at a locale map or a bare value, so handing them the resolved field
+ * keeps that decision correct without each one needing to know about absorption.
+ * The field is returned as-is when nothing changes, so the common path allocates
+ * nothing and any narrowing the caller has already done survives.
+ */
+export declare function resolveFieldLocalization<TField extends Field | TabAsField>({ field, isAbsorbed, }: ResolveFieldLocalizationOptions<TField>): TField;
+export {};

package/dist/db-content-api/utilities/data/resolveFieldLocalization.js

@@ -0,0 +1,21 @@
+/**
+ * Returns the field with `localized` collapsed to whether locale keys actually
+ * appear in its data — `false` for a field whose localized ancestor already
+ * absorbed them (see `createIsLocaleAbsorbed`).
+ *
+ * Every value-shaping helper keys off `field.localized` to decide whether it is
+ * looking at a locale map or a bare value, so handing them the resolved field
+ * keeps that decision correct without each one needing to know about absorption.
+ * The field is returned as-is when nothing changes, so the common path allocates
+ * nothing and any narrowing the caller has already done survives.
+ */ export function resolveFieldLocalization({ field, isAbsorbed }) {
+    if (!isAbsorbed || !('localized' in field) || field.localized !== true) {
+        return field;
+    }
+    // Only `localized` changes, so the result is still the same field type; TypeScript
+    // cannot see that through a spread of a generic union member.
+    return {
+        ...field,
+        localized: false
+    };
+}

package/dist/db-content-api/utilities/data/richTextShape.d.ts

@@ -0,0 +1,3 @@
+import type { Field, Payload, TabAsField } from 'payload';
+export declare function encodeRichTextForWrite(field: Field | TabAsField, value: unknown): unknown;
+export declare function decodeRichTextFromRead(field: Field | TabAsField, value: unknown, payload: Payload, fieldPath: string, collectionSlug: string): unknown;