@datocms/cma-client 5.1.9 → 5.1.11

package/dist/esm/utilities/{fieldValue.js → normalizedFieldValues.js}

@@ -19,6 +19,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 export function isLocalized(field) {
     return 'attributes' in field ? field.attributes.localized : field.localized;
 }
+export function isLocalizedFieldValue(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const keys = Object.keys(value);
+    if (keys.length === 0) {
+        return false;
+    }
+    const localePattern = /^[A-Za-z]{2,4}(-[A-Za-z]{4})?(-([A-Za-z]{2}|[0-9]{3}))?$/;
+    return keys.every((key) => localePattern.test(key));
+}
 /**
  * Converts a field value (localized or non-localized) into a uniform array of entries.
  *
@@ -29,7 +40,7 @@ export function isLocalized(field) {
  * @param value - The field value to convert (either a localized object or direct value)
  * @returns Array of entries where each entry contains a locale (string for localized, undefined for non-localized) and the corresponding value
  */
-export function fieldValueToEntries(field, value) {
+export function toNormalizedFieldValueEntries(field, value) {
     if (isLocalized(field)) {
         const localizedValue = value;
         return Object.entries(localizedValue).map(([locale, value]) => ({
@@ -42,7 +53,7 @@ export function fieldValueToEntries(field, value) {
 /**
  * Converts an array of possibly localized entries back into the appropriate field value format.
  *
- * This function is the inverse of `fieldValueToEntries`. It takes a uniform
+ * This function is the inverse of `toNormalizedFieldValueEntries`. It takes a uniform
  * array of entries and converts them back to either a localized object or a direct value,
  * depending on the field's localization setting.
  *
@@ -50,7 +61,7 @@ export function fieldValueToEntries(field, value) {
  * @param entries - Array of entries to convert back to field value format
  * @returns Either a localized object (for localized fields) or the direct value (for non-localized fields)
  */
-export function entriesToFieldValue(field, entries) {
+export function fromNormalizedFieldValueEntries(field, entries) {
     if (isLocalized(field)) {
         return Object.fromEntries(entries.map(({ locale, value }) => [locale, value]));
     }
@@ -70,13 +81,13 @@ export function entriesToFieldValue(field, entries) {
  * @param mapFn - The function to apply to each locale value or the direct value
  * @returns The mapped value with the same structure as the input
  */
-export function mapFieldValue(field, value, mapFn) {
-    const entries = fieldValueToEntries(field, value);
+export function mapNormalizedFieldValues(field, value, mapFn) {
+    const entries = toNormalizedFieldValueEntries(field, value);
     const mappedEntries = entries.map(({ locale, value }) => ({
         locale,
         value: mapFn(locale, value),
     }));
-    return entriesToFieldValue(field, mappedEntries);
+    return fromNormalizedFieldValueEntries(field, mappedEntries);
 }
 /**
  * Maps field values using a provided mapping function (async version).
@@ -89,16 +100,16 @@ export function mapFieldValue(field, value, mapFn) {
  * @param mapFn - The function to apply to each locale value or the direct value
  * @returns The mapped value with the same structure as the input
  */
-export function mapFieldValueAsync(field, value, mapFn) {
+export function mapNormalizedFieldValuesAsync(field, value, mapFn) {
     return __awaiter(this, void 0, void 0, function* () {
-        const entries = fieldValueToEntries(field, value);
+        const entries = toNormalizedFieldValueEntries(field, value);
         const mappedEntries = yield Promise.all(entries.map(({ locale, value }) => __awaiter(this, void 0, void 0, function* () {
             return ({
                 locale,
                 value: yield mapFn(locale, value),
             });
         })));
-        return entriesToFieldValue(field, mappedEntries);
+        return fromNormalizedFieldValueEntries(field, mappedEntries);
     });
 }
 /**
@@ -111,12 +122,12 @@ export function mapFieldValueAsync(field, value, mapFn) {
  * @param filterFn - The function to test each locale value or the direct value
  * @returns The filtered value with the same structure as the input
  */
-export function filterFieldValue(field, value, filterFn) {
+export function filterNormalizedFieldValues(field, value, filterFn) {
     var _a;
-    const entries = fieldValueToEntries(field, value);
+    const entries = toNormalizedFieldValueEntries(field, value);
     const filteredEntries = entries.filter((entry) => filterFn(entry.locale, entry.value));
     if (isLocalized(field)) {
-        return entriesToFieldValue(field, filteredEntries);
+        return fromNormalizedFieldValueEntries(field, filteredEntries);
     }
     return filteredEntries.length > 0 ? (_a = filteredEntries[0]) === null || _a === void 0 ? void 0 : _a.value : undefined;
 }
@@ -130,10 +141,10 @@ export function filterFieldValue(field, value, filterFn) {
  * @param filterFn - The function to test each locale value or the direct value
  * @returns The filtered value with the same structure as the input
  */
-export function filterFieldValueAsync(field, value, filterFn) {
+export function filterNormalizedFieldValuesAsync(field, value, filterFn) {
     var _a;
     return __awaiter(this, void 0, void 0, function* () {
-        const entries = fieldValueToEntries(field, value);
+        const entries = toNormalizedFieldValueEntries(field, value);
         const results = yield Promise.all(entries.map(({ locale, value }) => __awaiter(this, void 0, void 0, function* () {
             return ({
                 locale,
@@ -145,7 +156,7 @@ export function filterFieldValueAsync(field, value, filterFn) {
             .filter(({ passed }) => passed)
             .map(({ locale, value }) => ({ locale, value }));
         if (isLocalized(field)) {
-            return entriesToFieldValue(field, filteredEntries);
+            return fromNormalizedFieldValueEntries(field, filteredEntries);
         }
         return filteredEntries.length > 0 ? (_a = filteredEntries[0]) === null || _a === void 0 ? void 0 : _a.value : undefined;
     });
@@ -160,8 +171,8 @@ export function filterFieldValueAsync(field, value, filterFn) {
  * @param testFn - The function to test each locale value or the direct value
  * @returns true if at least one value passes the test, false otherwise
  */
-export function someFieldValue(field, value, testFn) {
-    const entries = fieldValueToEntries(field, value);
+export function someNormalizedFieldValues(field, value, testFn) {
+    const entries = toNormalizedFieldValueEntries(field, value);
     return entries.some(({ locale, value }) => testFn(locale, value));
 }
 /**
@@ -174,9 +185,9 @@ export function someFieldValue(field, value, testFn) {
  * @param testFn - The function to test each locale value or the direct value
  * @returns true if at least one value passes the test, false otherwise
  */
-export function someFieldValueAsync(field, value, testFn) {
+export function someNormalizedFieldValuesAsync(field, value, testFn) {
     return __awaiter(this, void 0, void 0, function* () {
-        const entries = fieldValueToEntries(field, value);
+        const entries = toNormalizedFieldValueEntries(field, value);
         const results = yield Promise.all(entries.map(({ locale, value }) => testFn(locale, value)));
         return results.some((result) => result);
     });
@@ -191,8 +202,8 @@ export function someFieldValueAsync(field, value, testFn) {
  * @param testFn - The function to test each locale value or the direct value
  * @returns true if all values pass the test, false otherwise
  */
-export function everyFieldValue(field, value, testFn) {
-    return !someFieldValue(field, value, (locale, localeValue) => !testFn(locale, localeValue));
+export function everyNormalizedFieldValue(field, value, testFn) {
+    return !someNormalizedFieldValues(field, value, (locale, localeValue) => !testFn(locale, localeValue));
 }
 /**
  * Tests whether all field values pass the test implemented by the provided function (async version).
@@ -204,9 +215,9 @@ export function everyFieldValue(field, value, testFn) {
  * @param testFn - The function to test each locale value or the direct value
  * @returns true if all values pass the test, false otherwise
  */
-export function everyFieldValueAsync(field, value, testFn) {
+export function everyNormalizedFieldValueAsync(field, value, testFn) {
     return __awaiter(this, void 0, void 0, function* () {
-        return !(yield someFieldValueAsync(field, value, (locale, localeValue) => __awaiter(this, void 0, void 0, function* () { return !(yield testFn(locale, localeValue)); })));
+        return !(yield someNormalizedFieldValuesAsync(field, value, (locale, localeValue) => __awaiter(this, void 0, void 0, function* () { return !(yield testFn(locale, localeValue)); })));
     });
 }
 /**
@@ -218,8 +229,8 @@ export function everyFieldValueAsync(field, value, testFn) {
  * @param value - The field value (either localized object or direct value)
  * @param visitFn - The function to call for each locale value or the direct value
  */
-export function visitFieldValue(field, value, visitFn) {
-    const entries = fieldValueToEntries(field, value);
+export function visitNormalizedFieldValues(field, value, visitFn) {
+    const entries = toNormalizedFieldValueEntries(field, value);
     for (const { locale, value } of entries) {
         visitFn(locale, value);
     }
@@ -233,10 +244,10 @@ export function visitFieldValue(field, value, visitFn) {
  * @param value - The field value (either localized object or direct value)
  * @param visitFn - The function to call for each locale value or the direct value
  */
-export function visitFieldValueAsync(field, value, visitFn) {
+export function visitNormalizedFieldValuesAsync(field, value, visitFn) {
     return __awaiter(this, void 0, void 0, function* () {
-        const entries = fieldValueToEntries(field, value);
+        const entries = toNormalizedFieldValueEntries(field, value);
         yield Promise.all(entries.map(({ locale, value }) => visitFn(locale, value)));
     });
 }
-//# sourceMappingURL=fieldValue.js.map
+//# sourceMappingURL=normalizedFieldValues.js.map

package/dist/esm/utilities/normalizedFieldValues.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizedFieldValues.js","sourceRoot":"","sources":["../../../src/utilities/normalizedFieldValues.ts"],"names":[],"mappings":"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"}

package/dist/esm/utilities/recursiveBlocks.d.ts

@@ -1,18 +1,101 @@
 import { type BlockItemInARequest } from '../fieldTypes';
 import type * as ApiTypes from '../generated/ApiTypes';
-import type * as RawApiTypes from '../generated/RawApiTypes';
 import type { SchemaRepository } from './schemaRepository';
 /**
- * Path through a field value (ie. ['content', 0, 'attributes', 'title'])
+ * Path through a non-localized field value (ie. ['content', 0, 'attributes', 'title'])
  */
 export type TreePath = readonly (string | number)[];
-export declare function visitBlocksInFieldValues(schemaRepository: SchemaRepository, field: RawApiTypes.Field | ApiTypes.Field, value: unknown, visitor: (item: BlockItemInARequest, path: TreePath) => void | Promise<void>, path?: TreePath): Promise<void>;
-export declare function findAllBlocksInFieldValues(schemaRepository: SchemaRepository, field: RawApiTypes.Field | ApiTypes.Field, value: unknown, predicate: (item: BlockItemInARequest, path: TreePath) => boolean | Promise<boolean>, path?: TreePath): Promise<Array<{
+/**
+ * Recursively visit every block in a non-localized field value and all nested blocks within those blocks.
+ * This function traverses not only the direct blocks in the non-localized field value but also recursively
+ * visits blocks contained within the attributes of each block, creating a complete traversal
+ * of the entire block hierarchy.
+ *
+ * @param schemaRepository - Repository for accessing DatoCMS schema information to resolve block structures
+ * @param fieldType - The type of DatoCMS field definition that determines how the value is processed
+ * @param nonLocalizedFieldValue - The non-localized field value containing blocks to visit
+ * @param visitor - Asynchronous function called for each block found, including nested blocks
+ * @returns Promise that resolves when all blocks and nested blocks have been visited
+ */
+export declare function visitBlocksInNonLocalizedFieldValue(schemaRepository: SchemaRepository, fieldType: ApiTypes.Field['field_type'], nonLocalizedFieldValue: unknown, visitor: (item: BlockItemInARequest, path: TreePath) => void | Promise<void>, path?: TreePath): Promise<void>;
+/**
+ * Recursively find all blocks that match the predicate function in a non-localized field value.
+ * Searches through all direct blocks and recursively through nested blocks within
+ * the attributes of each block, returning all matches found throughout the hierarchy.
+ *
+ * @param schemaRepository - Repository for accessing DatoCMS schema information to resolve block structures
+ * @param fieldType - The type of DatoCMS field definition that determines how the value is processed
+ * @param nonLocalizedFieldValue - The non-localized field value containing blocks to search
+ * @param predicate - Asynchronous function that tests each block, including nested ones
+ * @returns Promise that resolves to an array of objects, each containing a matching block and its full path
+ */
+export declare function findAllBlocksInNonLocalizedFieldValue(schemaRepository: SchemaRepository, fieldType: ApiTypes.Field['field_type'], nonLocalizedFieldValue: unknown, predicate: (item: BlockItemInARequest, path: TreePath) => boolean | Promise<boolean>, path?: TreePath): Promise<Array<{
     item: BlockItemInARequest;
     path: TreePath;
 }>>;
-export declare function filterBlocksInFieldValues(schemaRepository: SchemaRepository, field: RawApiTypes.Field | ApiTypes.Field, value: unknown, predicate: (item: BlockItemInARequest, path: TreePath) => boolean | Promise<boolean>, path?: TreePath): Promise<unknown>;
-export declare function reduceBlocksInFieldValues<R>(schemaRepository: SchemaRepository, field: RawApiTypes.Field | ApiTypes.Field, value: unknown, reducer: (accumulator: R, item: BlockItemInARequest, path: TreePath) => R | Promise<R>, initialValue: R, path?: TreePath): Promise<R>;
-export declare function someBlocksInFieldValues(schemaRepository: SchemaRepository, field: RawApiTypes.Field | ApiTypes.Field, value: unknown, predicate: (item: BlockItemInARequest, path: TreePath) => boolean | Promise<boolean>, path?: TreePath): Promise<boolean>;
-export declare function everyBlockInFieldValues(schemaRepository: SchemaRepository, field: RawApiTypes.Field | ApiTypes.Field, value: unknown, predicate: (item: BlockItemInARequest, path: TreePath) => boolean | Promise<boolean>, path?: TreePath): Promise<boolean>;
-export declare function mapBlocksInFieldValues(schemaRepository: SchemaRepository, field: RawApiTypes.Field | ApiTypes.Field, value: unknown, mapper: (item: BlockItemInARequest, path: TreePath) => BlockItemInARequest | Promise<BlockItemInARequest>, path?: TreePath): Promise<unknown>;
+/**
+ * Recursively filter blocks in a non-localized field value, removing those that don't match the predicate.
+ * Creates a new non-localized field value structure containing only blocks that pass the predicate test,
+ * including recursive filtering of nested blocks within block attributes. The filtering
+ * preserves the original non-localized field value structure and hierarchy.
+ *
+ * @param schemaRepository - Repository for accessing DatoCMS schema information to resolve block structures
+ * @param fieldType - The type of DatoCMS field definition that determines how the value is processed
+ * @param nonLocalizedFieldValue - The non-localized field value containing blocks to filter
+ * @param predicate - Asynchronous function that tests each block, including nested ones
+ * @returns Promise that resolves to the new non-localized field value with recursively filtered blocks
+ */
+export declare function filterBlocksInNonLocalizedFieldValue(schemaRepository: SchemaRepository, fieldType: ApiTypes.Field['field_type'], nonLocalizedFieldValue: unknown, predicate: (item: BlockItemInARequest, path: TreePath) => boolean | Promise<boolean>, path?: TreePath): Promise<unknown>;
+/**
+ * Recursively reduce all blocks in a non-localized field value to a single value by applying a reducer function.
+ * Processes each direct block and recursively processes nested blocks within block attributes,
+ * accumulating results from the entire block hierarchy into a single value.
+ *
+ * @template R - The type of the accumulated result
+ * @param schemaRepository - Repository for accessing DatoCMS schema information to resolve block structures
+ * @param fieldType - The type of DatoCMS field definition that determines how the value is processed
+ * @param nonLocalizedFieldValue - The non-localized field value containing blocks to reduce
+ * @param reducer - Asynchronous function that processes each block and updates the accumulator
+ * @param initialNonLocalizedFieldValue - The initial value for the accumulator
+ * @returns Promise that resolves to the final accumulated value from all blocks in the hierarchy
+ */
+export declare function reduceBlocksInNonLocalizedFieldValue<R>(schemaRepository: SchemaRepository, fieldType: ApiTypes.Field['field_type'], nonLocalizedFieldValue: unknown, reducer: (accumulator: R, item: BlockItemInARequest, path: TreePath) => R | Promise<R>, initialValue: R, path?: TreePath): Promise<R>;
+/**
+ * Recursively check if any block in the non-localized field value matches the predicate function.
+ * Tests both direct blocks and recursively tests nested blocks within block attributes.
+ * Returns true as soon as the first matching block is found anywhere in the hierarchy
+ * (short-circuit evaluation).
+ *
+ * @param schemaRepository - Repository for accessing DatoCMS schema information to resolve block structures
+ * @param fieldType - The type of DatoCMS field definition that determines how the value is processed
+ * @param nonLocalizedFieldValue - The non-localized field value containing blocks to test
+ * @param predicate - Asynchronous function that tests each block, including nested ones
+ * @returns Promise that resolves to true if any block in the hierarchy matches, false otherwise
+ */
+export declare function someBlocksInNonLocalizedFieldValue(schemaRepository: SchemaRepository, fieldType: ApiTypes.Field['field_type'], nonLocalizedFieldValue: unknown, predicate: (item: BlockItemInARequest, path: TreePath) => boolean | Promise<boolean>, path?: TreePath): Promise<boolean>;
+/**
+ * Recursively check if every block in the non-localized field value matches the predicate function.
+ * Tests both direct blocks and recursively tests nested blocks within block attributes.
+ * Returns false as soon as the first non-matching block is found anywhere in the hierarchy
+ * (short-circuit evaluation).
+ *
+ * @param schemaRepository - Repository for accessing DatoCMS schema information to resolve block structures
+ * @param fieldType - The type of DatoCMS field definition that determines how the value is processed
+ * @param nonLocalizedFieldValue - The non-localized field value containing blocks to test
+ * @param predicate - Asynchronous function that tests each block, including nested ones
+ * @returns Promise that resolves to true if all blocks in the hierarchy match, false otherwise
+ */
+export declare function everyBlockInNonLocalizedFieldValue(schemaRepository: SchemaRepository, fieldType: ApiTypes.Field['field_type'], nonLocalizedFieldValue: unknown, predicate: (item: BlockItemInARequest, path: TreePath) => boolean | Promise<boolean>, path?: TreePath): Promise<boolean>;
+/**
+ * Recursively transform blocks in a non-localized field value by applying a mapping function to each block.
+ * Creates a new non-localized field value structure with transformed blocks while preserving the original
+ * structure. Applies the mapping function to both direct blocks and recursively to nested
+ * blocks within block attributes throughout the entire hierarchy.
+ *
+ * @param schemaRepository - Repository for accessing DatoCMS schema information to resolve block structures
+ * @param fieldType - The type of DatoCMS field definition that determines how the value is processed
+ * @param nonLocalizedFieldValue - The non-localized field value containing blocks to transform
+ * @param mapper - Asynchronous function that transforms each block, including nested ones
+ * @returns Promise that resolves to the new non-localized field value with recursively transformed blocks
+ */
+export declare function mapBlocksInNonLocalizedFieldValue(schemaRepository: SchemaRepository, fieldType: ApiTypes.Field['field_type'], nonLocalizedFieldValue: unknown, mapper: (item: BlockItemInARequest, path: TreePath) => BlockItemInARequest | Promise<BlockItemInARequest>, path?: TreePath): Promise<unknown>;

package/dist/esm/utilities/recursiveBlocks.js

@@ -8,11 +8,22 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { isItemWithOptionalIdAndMeta, } from '../fieldTypes';
-import { nonRecursiveFilterBlocksInFieldValueAsync, nonRecursiveFindAllBlocksInFieldValueAsync, nonRecursiveMapBlocksInFieldValueAsync, nonRecursiveReduceBlocksInFieldValueAsync, nonRecursiveSomeBlocksInFieldValueAsync, nonRecursiveVisitBlocksInFieldValueAsync, } from './blocks';
-import { mapFieldValueAsync, visitFieldValueAsync } from './fieldValue';
-export function visitBlocksInFieldValues(schemaRepository, field, value, visitor, path = []) {
+import { nonRecursiveFilterBlocksInNonLocalizedFieldValueAsync, nonRecursiveFindAllBlocksInNonLocalizedFieldValueAsync, nonRecursiveMapBlocksInNonLocalizedFieldValueAsync, nonRecursiveReduceBlocksInNonLocalizedFieldValueAsync, nonRecursiveSomeBlocksInNonLocalizedFieldValueAsync, nonRecursiveVisitBlocksInNonLocalizedFieldValueAsync, } from './nonRecursiveBlocks';
+/**
+ * Recursively visit every block in a non-localized field value and all nested blocks within those blocks.
+ * This function traverses not only the direct blocks in the non-localized field value but also recursively
+ * visits blocks contained within the attributes of each block, creating a complete traversal
+ * of the entire block hierarchy.
+ *
+ * @param schemaRepository - Repository for accessing DatoCMS schema information to resolve block structures
+ * @param fieldType - The type of DatoCMS field definition that determines how the value is processed
+ * @param nonLocalizedFieldValue - The non-localized field value containing blocks to visit
+ * @param visitor - Asynchronous function called for each block found, including nested blocks
+ * @returns Promise that resolves when all blocks and nested blocks have been visited
+ */
+export function visitBlocksInNonLocalizedFieldValue(schemaRepository, fieldType, nonLocalizedFieldValue, visitor, path = []) {
     return __awaiter(this, void 0, void 0, function* () {
-        yield nonRecursiveVisitBlocksInFieldValueAsync(field, value, (block, innerPath) => __awaiter(this, void 0, void 0, function* () {
+        yield nonRecursiveVisitBlocksInNonLocalizedFieldValueAsync(fieldType, nonLocalizedFieldValue, (block, innerPath) => __awaiter(this, void 0, void 0, function* () {
             yield visitor(block, [...path, ...innerPath]);
             if (!isItemWithOptionalIdAndMeta(block)) {
                 return;
@@ -20,50 +31,59 @@ export function visitBlocksInFieldValues(schemaRepository, field, value, visitor
             const itemType = yield schemaRepository.getRawItemTypeById(block.relationships.item_type.data.id);
             const fields = yield schemaRepository.getRawItemTypeFields(itemType);
             for (const field of fields) {
-                yield visitFieldValueAsync(field, block.attributes[field.attributes.api_key], (locale, valueForLocale) => visitBlocksInFieldValues(schemaRepository, field, valueForLocale, visitor, [
-                    ...path,
-                    ...innerPath,
-                    'attributes',
-                    field.attributes.api_key,
-                    ...(locale ? [locale] : []),
-                ]));
+                yield visitBlocksInNonLocalizedFieldValue(schemaRepository, fieldType, block.attributes[field.attributes.api_key], visitor, [...path, ...innerPath, 'attributes', field.attributes.api_key]);
             }
         }));
     });
 }
-export function findAllBlocksInFieldValues(schemaRepository, field, value, predicate, path = []) {
+/**
+ * Recursively find all blocks that match the predicate function in a non-localized field value.
+ * Searches through all direct blocks and recursively through nested blocks within
+ * the attributes of each block, returning all matches found throughout the hierarchy.
+ *
+ * @param schemaRepository - Repository for accessing DatoCMS schema information to resolve block structures
+ * @param fieldType - The type of DatoCMS field definition that determines how the value is processed
+ * @param nonLocalizedFieldValue - The non-localized field value containing blocks to search
+ * @param predicate - Asynchronous function that tests each block, including nested ones
+ * @returns Promise that resolves to an array of objects, each containing a matching block and its full path
+ */
+export function findAllBlocksInNonLocalizedFieldValue(schemaRepository, fieldType, nonLocalizedFieldValue, predicate, path = []) {
     return __awaiter(this, void 0, void 0, function* () {
         const results = [];
-        const directMatches = yield nonRecursiveFindAllBlocksInFieldValueAsync(field, value, (block, innerPath) => __awaiter(this, void 0, void 0, function* () { return yield predicate(block, [...path, ...innerPath]); }));
+        const directMatches = yield nonRecursiveFindAllBlocksInNonLocalizedFieldValueAsync(fieldType, nonLocalizedFieldValue, (block, innerPath) => __awaiter(this, void 0, void 0, function* () { return yield predicate(block, [...path, ...innerPath]); }));
         results.push(...directMatches.map(({ item, path: innerPath }) => ({
             item,
             path: [...path, ...innerPath],
         })));
-        yield nonRecursiveVisitBlocksInFieldValueAsync(field, value, (block, innerPath) => __awaiter(this, void 0, void 0, function* () {
+        yield nonRecursiveVisitBlocksInNonLocalizedFieldValueAsync(fieldType, nonLocalizedFieldValue, (block, innerPath) => __awaiter(this, void 0, void 0, function* () {
             if (!isItemWithOptionalIdAndMeta(block)) {
                 return;
             }
             const itemType = yield schemaRepository.getRawItemTypeById(block.relationships.item_type.data.id);
             const fields = yield schemaRepository.getRawItemTypeFields(itemType);
             for (const field of fields) {
-                yield visitFieldValueAsync(field, block.attributes[field.attributes.api_key], (locale, valueForLocale) => __awaiter(this, void 0, void 0, function* () {
-                    const nestedResults = yield findAllBlocksInFieldValues(schemaRepository, field, valueForLocale, predicate, [
-                        ...path,
-                        ...innerPath,
-                        'attributes',
-                        field.attributes.api_key,
-                        ...(locale ? [locale] : []),
-                    ]);
-                    results.push(...nestedResults);
-                }));
+                const nestedResults = yield findAllBlocksInNonLocalizedFieldValue(schemaRepository, fieldType, block.attributes[field.attributes.api_key], predicate, [...path, ...innerPath, 'attributes', field.attributes.api_key]);
+                results.push(...nestedResults);
             }
         }));
         return results;
     });
 }
-export function filterBlocksInFieldValues(schemaRepository, field, value, predicate, path = []) {
+/**
+ * Recursively filter blocks in a non-localized field value, removing those that don't match the predicate.
+ * Creates a new non-localized field value structure containing only blocks that pass the predicate test,
+ * including recursive filtering of nested blocks within block attributes. The filtering
+ * preserves the original non-localized field value structure and hierarchy.
+ *
+ * @param schemaRepository - Repository for accessing DatoCMS schema information to resolve block structures
+ * @param fieldType - The type of DatoCMS field definition that determines how the value is processed
+ * @param nonLocalizedFieldValue - The non-localized field value containing blocks to filter
+ * @param predicate - Asynchronous function that tests each block, including nested ones
+ * @returns Promise that resolves to the new non-localized field value with recursively filtered blocks
+ */
+export function filterBlocksInNonLocalizedFieldValue(schemaRepository, fieldType, nonLocalizedFieldValue, predicate, path = []) {
     return __awaiter(this, void 0, void 0, function* () {
-        return nonRecursiveFilterBlocksInFieldValueAsync(field, value, (block, innerPath) => __awaiter(this, void 0, void 0, function* () {
+        return nonRecursiveFilterBlocksInNonLocalizedFieldValueAsync(fieldType, nonLocalizedFieldValue, (block, innerPath) => __awaiter(this, void 0, void 0, function* () {
             const blockPath = [...path, ...innerPath];
             const passes = yield predicate(block, blockPath);
             if (!passes) {
@@ -75,49 +95,62 @@ export function filterBlocksInFieldValues(schemaRepository, field, value, predic
             const itemType = yield schemaRepository.getRawItemTypeById(block.relationships.item_type.data.id);
             const fields = yield schemaRepository.getRawItemTypeFields(itemType);
             for (const field of fields) {
-                block.attributes[field.attributes.api_key] = yield mapFieldValueAsync(field, block.attributes[field.attributes.api_key], (locale, valueForLocale) => filterBlocksInFieldValues(schemaRepository, field, valueForLocale, predicate, [
-                    ...blockPath,
-                    'attributes',
-                    field.attributes.api_key,
-                    ...(locale ? [locale] : []),
-                ]));
+                block.attributes[field.attributes.api_key] =
+                    yield filterBlocksInNonLocalizedFieldValue(schemaRepository, fieldType, block.attributes[field.attributes.api_key], predicate, [...blockPath, 'attributes', field.attributes.api_key]);
             }
             return true;
         }));
     });
 }
-export function reduceBlocksInFieldValues(schemaRepository, field, value, reducer, initialValue, path = []) {
+/**
+ * Recursively reduce all blocks in a non-localized field value to a single value by applying a reducer function.
+ * Processes each direct block and recursively processes nested blocks within block attributes,
+ * accumulating results from the entire block hierarchy into a single value.
+ *
+ * @template R - The type of the accumulated result
+ * @param schemaRepository - Repository for accessing DatoCMS schema information to resolve block structures
+ * @param fieldType - The type of DatoCMS field definition that determines how the value is processed
+ * @param nonLocalizedFieldValue - The non-localized field value containing blocks to reduce
+ * @param reducer - Asynchronous function that processes each block and updates the accumulator
+ * @param initialNonLocalizedFieldValue - The initial value for the accumulator
+ * @returns Promise that resolves to the final accumulated value from all blocks in the hierarchy
+ */
+export function reduceBlocksInNonLocalizedFieldValue(schemaRepository, fieldType, nonLocalizedFieldValue, reducer, initialValue, path = []) {
     return __awaiter(this, void 0, void 0, function* () {
-        let accumulator = yield nonRecursiveReduceBlocksInFieldValueAsync(field, value, (acc, block, innerPath) => __awaiter(this, void 0, void 0, function* () { return yield reducer(acc, block, [...path, ...innerPath]); }), initialValue);
-        yield nonRecursiveVisitBlocksInFieldValueAsync(field, value, (block, innerPath) => __awaiter(this, void 0, void 0, function* () {
+        let accumulator = yield nonRecursiveReduceBlocksInNonLocalizedFieldValueAsync(fieldType, nonLocalizedFieldValue, (acc, block, innerPath) => __awaiter(this, void 0, void 0, function* () { return yield reducer(acc, block, [...path, ...innerPath]); }), initialValue);
+        yield nonRecursiveVisitBlocksInNonLocalizedFieldValueAsync(fieldType, nonLocalizedFieldValue, (block, innerPath) => __awaiter(this, void 0, void 0, function* () {
             if (!isItemWithOptionalIdAndMeta(block)) {
                 return;
             }
             const itemType = yield schemaRepository.getRawItemTypeById(block.relationships.item_type.data.id);
             const fields = yield schemaRepository.getRawItemTypeFields(itemType);
             for (const field of fields) {
-                yield visitFieldValueAsync(field, block.attributes[field.attributes.api_key], (locale, valueForLocale) => __awaiter(this, void 0, void 0, function* () {
-                    accumulator = yield reduceBlocksInFieldValues(schemaRepository, field, valueForLocale, reducer, accumulator, [
-                        ...path,
-                        ...innerPath,
-                        'attributes',
-                        field.attributes.api_key,
-                        ...(locale ? [locale] : []),
-                    ]);
-                }));
+                accumulator = yield reduceBlocksInNonLocalizedFieldValue(schemaRepository, fieldType, block.attributes[field.attributes.api_key], reducer, accumulator, [...path, ...innerPath, 'attributes', field.attributes.api_key]);
             }
         }));
         return accumulator;
     });
 }
-export function someBlocksInFieldValues(schemaRepository, field, value, predicate, path = []) {
+/**
+ * Recursively check if any block in the non-localized field value matches the predicate function.
+ * Tests both direct blocks and recursively tests nested blocks within block attributes.
+ * Returns true as soon as the first matching block is found anywhere in the hierarchy
+ * (short-circuit evaluation).
+ *
+ * @param schemaRepository - Repository for accessing DatoCMS schema information to resolve block structures
+ * @param fieldType - The type of DatoCMS field definition that determines how the value is processed
+ * @param nonLocalizedFieldValue - The non-localized field value containing blocks to test
+ * @param predicate - Asynchronous function that tests each block, including nested ones
+ * @returns Promise that resolves to true if any block in the hierarchy matches, false otherwise
+ */
+export function someBlocksInNonLocalizedFieldValue(schemaRepository, fieldType, nonLocalizedFieldValue, predicate, path = []) {
     return __awaiter(this, void 0, void 0, function* () {
-        const directMatch = yield nonRecursiveSomeBlocksInFieldValueAsync(field, value, (block, innerPath) => __awaiter(this, void 0, void 0, function* () { return yield predicate(block, [...path, ...innerPath]); }));
+        const directMatch = yield nonRecursiveSomeBlocksInNonLocalizedFieldValueAsync(fieldType, nonLocalizedFieldValue, (block, innerPath) => __awaiter(this, void 0, void 0, function* () { return yield predicate(block, [...path, ...innerPath]); }));
         if (directMatch) {
             return true;
         }
         let found = false;
-        yield nonRecursiveVisitBlocksInFieldValueAsync(field, value, (block, innerPath) => __awaiter(this, void 0, void 0, function* () {
+        yield nonRecursiveVisitBlocksInNonLocalizedFieldValueAsync(fieldType, nonLocalizedFieldValue, (block, innerPath) => __awaiter(this, void 0, void 0, function* () {
             if (found || !isItemWithOptionalIdAndMeta(block)) {
                 return;
             }
@@ -126,33 +159,47 @@ export function someBlocksInFieldValues(schemaRepository, field, value, predicat
             for (const field of fields) {
                 if (found)
                     break;
-                yield visitFieldValueAsync(field, block.attributes[field.attributes.api_key], (locale, valueForLocale) => __awaiter(this, void 0, void 0, function* () {
-                    if (found)
-                        return;
-                    const nestedMatch = yield someBlocksInFieldValues(schemaRepository, field, valueForLocale, predicate, [
-                        ...path,
-                        ...innerPath,
-                        'attributes',
-                        field.attributes.api_key,
-                        ...(locale ? [locale] : []),
-                    ]);
-                    if (nestedMatch) {
-                        found = true;
-                    }
-                }));
+                const nestedMatch = yield someBlocksInNonLocalizedFieldValue(schemaRepository, fieldType, block.attributes[field.attributes.api_key], predicate, [...path, ...innerPath, 'attributes', field.attributes.api_key]);
+                if (nestedMatch) {
+                    found = true;
+                }
             }
         }));
         return found;
     });
 }
-export function everyBlockInFieldValues(schemaRepository, field, value, predicate, path = []) {
+/**
+ * Recursively check if every block in the non-localized field value matches the predicate function.
+ * Tests both direct blocks and recursively tests nested blocks within block attributes.
+ * Returns false as soon as the first non-matching block is found anywhere in the hierarchy
+ * (short-circuit evaluation).
+ *
+ * @param schemaRepository - Repository for accessing DatoCMS schema information to resolve block structures
+ * @param fieldType - The type of DatoCMS field definition that determines how the value is processed
+ * @param nonLocalizedFieldValue - The non-localized field value containing blocks to test
+ * @param predicate - Asynchronous function that tests each block, including nested ones
+ * @returns Promise that resolves to true if all blocks in the hierarchy match, false otherwise
+ */
+export function everyBlockInNonLocalizedFieldValue(schemaRepository, fieldType, nonLocalizedFieldValue, predicate, path = []) {
     return __awaiter(this, void 0, void 0, function* () {
-        return !(yield someBlocksInFieldValues(schemaRepository, field, value, (item, path) => __awaiter(this, void 0, void 0, function* () { return !(yield predicate(item, path)); }), path));
+        return !(yield someBlocksInNonLocalizedFieldValue(schemaRepository, fieldType, nonLocalizedFieldValue, (item, path) => __awaiter(this, void 0, void 0, function* () { return !(yield predicate(item, path)); }), path));
     });
 }
-export function mapBlocksInFieldValues(schemaRepository, field, value, mapper, path = []) {
+/**
+ * Recursively transform blocks in a non-localized field value by applying a mapping function to each block.
+ * Creates a new non-localized field value structure with transformed blocks while preserving the original
+ * structure. Applies the mapping function to both direct blocks and recursively to nested
+ * blocks within block attributes throughout the entire hierarchy.
+ *
+ * @param schemaRepository - Repository for accessing DatoCMS schema information to resolve block structures
+ * @param fieldType - The type of DatoCMS field definition that determines how the value is processed
+ * @param nonLocalizedFieldValue - The non-localized field value containing blocks to transform
+ * @param mapper - Asynchronous function that transforms each block, including nested ones
+ * @returns Promise that resolves to the new non-localized field value with recursively transformed blocks
+ */
+export function mapBlocksInNonLocalizedFieldValue(schemaRepository, fieldType, nonLocalizedFieldValue, mapper, path = []) {
     return __awaiter(this, void 0, void 0, function* () {
-        return nonRecursiveMapBlocksInFieldValueAsync(field, value, (block, innerPath) => __awaiter(this, void 0, void 0, function* () {
+        return nonRecursiveMapBlocksInNonLocalizedFieldValueAsync(fieldType, nonLocalizedFieldValue, (block, innerPath) => __awaiter(this, void 0, void 0, function* () {
             const newBlock = yield mapper(block, [...path, ...innerPath]);
             if (!isItemWithOptionalIdAndMeta(newBlock)) {
                 return newBlock;
@@ -161,13 +208,7 @@ export function mapBlocksInFieldValues(schemaRepository, field, value, mapper, p
             const fields = yield schemaRepository.getRawItemTypeFields(itemType);
             for (const field of fields) {
                 newBlock.attributes[field.attributes.api_key] =
-                    yield mapFieldValueAsync(field, newBlock.attributes[field.attributes.api_key], (locale, valueForLocale) => mapBlocksInFieldValues(schemaRepository, field, valueForLocale, mapper, [
-                        ...path,
-                        ...innerPath,
-                        'attributes',
-                        field.attributes.api_key,
-                        ...(locale ? [locale] : []),
-                    ]));
+                    yield mapBlocksInNonLocalizedFieldValue(schemaRepository, fieldType, newBlock.attributes[field.attributes.api_key], mapper, [...path, ...innerPath, 'attributes', field.attributes.api_key]);
             }
             return newBlock;
         }));