fix(edit-content): parse block editor JSON strings when translating content

[oidacra]

Summary

• Add blockEditorResolutionFn that JSON.parse()s block editor values when they come as JSON strings from the API (happens during content translation/copy to new language)
• Previously, the block editor used defaultResolutionFn which returned the raw JSON string, causing the editor to display it as plain text instead of structured content

Closes #34025

Acceptance Criteria

• Block editor content is preserved as structured data when translating to a new language
• Object values (already parsed) pass through unchanged
• Non-JSON strings are returned as-is (no error)
• Null contentlet falls back to defaultValue

Test Plan

• yarn nx test edit-content --testPathPattern=dot-edit-content-form-resolutions — all tests pass
• 4 new tests for blockEditorResolutionFn
• Manual: Create content with block editor, translate to new language, verify formatting preserved

Changed Files

File	Change
libs/edit-content/.../dot-edit-content-form-resolutions.ts	Added blockEditorResolutionFn, mapped to FIELD_TYPES.BLOCK_EDITOR
libs/edit-content/.../dot-edit-content-form-resolutions.spec.ts	Added 4 tests, removed BLOCK_EDITOR from default fn group

This PR fixes: #34025

[claude]

Claude finished @oidacra's task in 3m 39s —— View job

---

Code Review

• Read changed files
• Analyze for bugs, edge cases, type issues, design problems
• Post findings

---

3 items worth a second look:

1. startsWith('{') heuristic silently skips non-object JSON

dot-edit-content-form-resolutions.ts:225

if (typeof value === 'string' && value.trim().startsWith('{')) {

Block editor documents ({type:'doc',...}) always start with {, so this works today. But the heuristic silently leaves a JSON string un-parsed if the translation API ever returns anything else (array root, quoted string, etc.). A more defensive alternative:

if (typeof value === 'string') {
    try {
        const parsed = JSON.parse(value);
        if (parsed !== null && typeof parsed === 'object') return parsed;
    } catch { /* not JSON */ }
}

This also removes the need for the startsWith pre-check entirely.

---

2. Round-trip contract is implicit — easy to break

blockEditorResolutionFn puts a parsed Record<string,unknown> into the FormControl. processFieldValue (in a different file) stringifies it back on submit. The only coupling is a comment. If processFieldValue is bypassed (different submit path, direct form patch, etc.) an object would reach the backend and be stored as [object Object]. This is the same bug the PR is fixing, just in a different code path.

Consider whether the stringify should live closer to where the block editor emits its value (it already calls JSON.stringify internally before emitting via onChange — dot-block-editor.component.ts:294). The form then only ever holds strings, and nothing downstream needs to know about the round-trip.

---

3. processFieldValue's BLOCK_EDITOR guard catches Date and arrays

functions.util.ts:631-637

if (field.fieldType === FIELD_TYPES.BLOCK_EDITOR && fieldValue && typeof fieldValue === 'object') {
    return JSON.stringify(fieldValue);
}

typeof new Date() === 'object' and typeof [] === 'object' are both true. Arrays are already handled above (CATEGORY / flattened), so an array here is only possible for corrupted data — JSON.stringify([]) is fine. But a stray Date value would produce "\"2026-...\"". Worth adding && !Array.isArray(fieldValue) && !(fieldValue instanceof Date) to make the intent explicit, or accepting this as an unreachable edge case.

---

Not a bug but notable: blockEditorResolutionFn is typed FnResolutionValue<string | Record<string, unknown>>, but field.defaultValue (and contentlet field access) is any, so the function can silently return null, undefined, or other types that don't satisfy the declared return type. This is consistent with every other resolution function in the file, so it's not new risk.

[Copilot]

Pull request overview

Fixes translated/copied Block Editor fields being displayed as plain text by parsing JSON-string values into structured objects during initial form value resolution.

Changes:

• Added a dedicated blockEditorResolutionFn that attempts to JSON.parse() Block Editor values when they arrive as JSON strings.
• Wired FIELD_TYPES.BLOCK_EDITOR to use the new resolution function instead of defaultResolutionFn.
• Added Jest tests covering Block Editor resolution behavior and removed BLOCK_EDITOR from the “default resolution fn” group.

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated 2 comments.

File	Description
core-web/libs/edit-content/src/lib/components/dot-edit-content-form/dot-edit-content-form-resolutions.ts	Introduces blockEditorResolutionFn and maps it to FIELD_TYPES.BLOCK_EDITOR so block editor receives structured data when API returns JSON strings.
core-web/libs/edit-content/src/lib/components/dot-edit-content-form/dot-edit-content-form-resolutions.spec.ts	Adds unit tests for Block Editor resolution and updates the default-mapping assertions accordingly.

[Copilot]

Pull request overview

Copilot reviewed 5 out of 5 changed files in this pull request and generated 1 comment.

Comments suppressed due to low confidence (1)

core-web/libs/edit-content/src/lib/utils/functions.util.ts:614

• processFieldValue now accepts Record<string, unknown>, but it calls isFlattenedField(fieldValue, field) where isFlattenedField is still typed to accept only string | string[] | Date | number | null | undefined. This makes the call site type-incompatible and can fail TypeScript compilation. Consider widening isFlattenedField's fieldValue parameter to include the new object type (or unknown) so it matches processFieldValue's input union.

export const processFieldValue = (
    fieldValue: string | string[] | Date | number | Record<string, unknown> | null | undefined,
    field: DotCMSContentTypeField
): string | number | null | undefined => {
    // Handle flattened fields (multi-select, etc.)
    if (isFlattenedField(fieldValue, field)) {
        return (fieldValue as string[]).join(',');
    }