@localazy/strapi-plugin 1.7.0 → 1.7.1

package/dist/server/index.js

@@ -20534,7 +20534,7 @@ var distExports = dist$1.exports;
 const io = /* @__PURE__ */ getDefaultExportFromCjs(distExports);
 const { Server: Server2, Namespace, Socket: Socket3 } = io;
 const name = "@localazy/strapi-plugin";
-const version = "1.7.0";
+const version = "1.7.1";
 const description = "The official Strapi Plugin by Localazy.";
 const keywords = [
   "strapi",
@@ -22052,7 +22052,7 @@ const findSetupModelByCollectionUid = (contentTransferSetup, strapiContentTypesM
   const modelContentTransferSetup = contentTransferSetup.setup.find(
     (model) => Object.keys(model)[0] === currentModel.collectionName
   );
-  return modelContentTransferSetup[currentModel.collectionName];
+  return modelContentTransferSetup?.[currentModel.collectionName];
 };
 const getCollectionsNames = (setup2) => {
   return getMainKeysOfNestedArrayObjects(setup2);
@@ -26199,9 +26199,6 @@ const LocalazyTransferUploadService = ({ strapi: strapi2 }) => ({
 const hasDynamicZoneKeySegment = (parsedKey) => {
   return parsedKey.some((segment) => segment.includes(";"));
 };
-const getDynamicZoneKeySegment = (parsedKey) => {
-  return parsedKey.find((segment) => segment.includes(";"));
-};
 const getComponentNameFromDynamicZoneKeySegment = (dynamicZoneKeySegment) => {
   return dynamicZoneKeySegment.split(";")[1];
 };
@@ -26221,52 +26218,116 @@ var ShouldSetDownloadedPropertyReturnType = /* @__PURE__ */ ((ShouldSetDownloade
   ShouldSetDownloadedPropertyReturnType2["JSON"] = "json";
   return ShouldSetDownloadedPropertyReturnType2;
 })(ShouldSetDownloadedPropertyReturnType || {});
-const shouldSetDownloadedProperty = (modelContentTransferSetup, parsedKeyRest) => {
+const locateDownloadedField = (modelContentTransferSetup, parsedKeyRest) => {
+  const notFound = { type: "no", fieldSegmentIndex: -1 };
   if (!modelContentTransferSetup.__model__) {
-    return "no";
+    return notFound;
   }
+  let setupModel = modelContentTransferSetup;
+  let startIndex2 = 0;
   if (hasDynamicZoneKeySegment(parsedKeyRest)) {
-    const dynamicZonePropertyName = getDynamicZonePropertyName(parsedKeyRest);
-    const componentName = getComponentNameFromDynamicZoneKeySegment(getDynamicZoneKeySegment(parsedKeyRest));
+    const dynamicZoneKeySegmentIndex = getDynamicZoneKeySegmentIndex(parsedKeyRest);
+    const componentName = getComponentNameFromDynamicZoneKeySegment(parsedKeyRest[dynamicZoneKeySegmentIndex]);
     const dzContentTransferSetupModel = get(
       modelContentTransferSetup,
-      dynamicZonePropertyName
+      getDynamicZonePropertyName(parsedKeyRest)
     );
     if (!Array.isArray(dzContentTransferSetupModel)) {
-      return "no";
+      return notFound;
     }
-    const dzContentTransferSetupComponentModel = dzContentTransferSetupModel.find(
-      (c2) => c2.__component__ === componentName
-    );
-    if (!dzContentTransferSetupComponentModel) {
-      return "no";
+    setupModel = dzContentTransferSetupModel.find((c2) => c2.__component__ === componentName);
+    if (!setupModel) {
+      return notFound;
     }
-    const dynamicZoneKeySegmentIndex = getDynamicZoneKeySegmentIndex(parsedKeyRest);
-    const slicedParsedKeyRest = parsedKeyRest.slice(dynamicZoneKeySegmentIndex + 1);
-    const filteredSlicedParsedKeyRest = slicedParsedKeyRest.filter((segment) => isNaN(parseInt(segment)));
-    if (get(dzContentTransferSetupComponentModel, filteredSlicedParsedKeyRest) === true) {
-      return "yes";
-    }
-    while (filteredSlicedParsedKeyRest.length > 0) {
-      filteredSlicedParsedKeyRest.pop();
-      if (get(dzContentTransferSetupComponentModel, filteredSlicedParsedKeyRest) === true) {
-        return "json";
+    startIndex2 = dynamicZoneKeySegmentIndex + 1;
+  }
+  const namedSegmentIndexes = [];
+  for (let index2 = startIndex2; index2 < parsedKeyRest.length; index2++) {
+    if (isNaN(parseInt(parsedKeyRest[index2]))) {
+      namedSegmentIndexes.push(index2);
+    }
+  }
+  for (let length2 = namedSegmentIndexes.length; length2 > 0; length2--) {
+    const fieldPath = namedSegmentIndexes.slice(0, length2).map((index2) => parsedKeyRest[index2]);
+    if (get(setupModel, fieldPath) === true) {
+      const fieldSegmentIndex = namedSegmentIndexes[length2 - 1];
+      const type2 = fieldSegmentIndex === parsedKeyRest.length - 1 ? "yes" : "json";
+      return { type: type2, fieldSegmentIndex };
+    }
+  }
+  return notFound;
+};
+const createJsonFieldsDownloadAccumulator = () => {
+  const fields = /* @__PURE__ */ new Map();
+  return {
+    /**
+     * @param fieldKey path to the field in the parsed content: `[iso, uid, documentId, ...ownerPath, fieldName]`
+     * @param valuePath path of this leaf inside the field's value
+     */
+    add(fieldKey, valuePath, value) {
+      const id = JSON.stringify(fieldKey);
+      let field = fields.get(id);
+      if (!field) {
+        field = { fieldKey, value: {} };
+        fields.set(id, field);
+      }
+      set(field.value, valuePath, value);
+    },
+    /** Write every collected field value into `parsedContent` at its own path. */
+    applyTo(parsedContent) {
+      for (const { fieldKey, value } of fields.values()) {
+        set(parsedContent, fieldKey, value);
       }
     }
-    return "no";
-  } else {
-    const filteredParsedKeyRest = parsedKeyRest.filter((partialKey) => isNaN(parseInt(partialKey)));
-    if (get(modelContentTransferSetup, filteredParsedKeyRest) === true) {
-      return "yes";
-    }
-    while (filteredParsedKeyRest.length > 0) {
-      filteredParsedKeyRest.pop();
-      if (get(modelContentTransferSetup, filteredParsedKeyRest) === true) {
-        return "json";
+  };
+};
+const collectDownloadedContent = ({
+  languages: languages2,
+  processedKeys,
+  contentTransferSetup,
+  models,
+  parseLocalazyKey: parseLocalazyKey2
+}) => {
+  const parsedLocalazyContent = {};
+  const entryKeySourceMap = {};
+  const jsonFieldsAccumulator = createJsonFieldsDownloadAccumulator();
+  for (const { isoStrapi, keys: keys2 } of languages2) {
+    const parsedKeys = keys2.map((localazyEntry) => {
+      const storedEvent = processedKeys[isoStrapi]?.[localazyEntry.id];
+      const isChanged = !(storedEvent !== void 0 && localazyEntry.event !== void 0 && localazyEntry.event <= storedEvent);
+      const parsedKey = parseLocalazyKey2(localazyEntry.key[0]);
+      return { localazyEntry, parsedKey, isChanged, entryKey: `${isoStrapi}:${parsedKey.uid}:${parsedKey.id}` };
+    });
+    for (const { localazyEntry, entryKey, isChanged } of parsedKeys) {
+      if (isChanged) {
+        if (!entryKeySourceMap[entryKey]) {
+          entryKeySourceMap[entryKey] = [];
+        }
+        entryKeySourceMap[entryKey].push({ lang: isoStrapi, id: localazyEntry.id, event: localazyEntry.event });
+      }
+    }
+    for (const { localazyEntry, parsedKey, entryKey } of parsedKeys) {
+      if (!entryKeySourceMap[entryKey]) {
+        continue;
+      }
+      const modelContentTransferSetup = findSetupModelByCollectionUid(contentTransferSetup, models, parsedKey.uid);
+      if (typeof modelContentTransferSetup === "undefined") {
+        continue;
+      }
+      const { type: type2, fieldSegmentIndex } = locateDownloadedField(modelContentTransferSetup, parsedKey.rest);
+      if (type2 === ShouldSetDownloadedPropertyReturnType.JSON) {
+        jsonFieldsAccumulator.add(
+          [isoStrapi, parsedKey.uid, parsedKey.id, ...parsedKey.rest.slice(0, fieldSegmentIndex + 1)],
+          parsedKey.rest.slice(fieldSegmentIndex + 1),
+          localazyEntry.value
+        );
+      } else if (type2 === ShouldSetDownloadedPropertyReturnType.YES) {
+        set(parsedLocalazyContent, [isoStrapi, parsedKey.uid, parsedKey.id, ...parsedKey.rest], localazyEntry.value);
       }
     }
-    return "no";
   }
+  jsonFieldsAccumulator.applyTo(parsedLocalazyContent);
+  return { parsedLocalazyContent, entryKeySourceMap };
 };
 const getFilteredLanguagesCodesForDownload = async (languagesCodes, requestedUiLanguages) => {
   const pluginSettingsServiceHelper = new PluginSettingsServiceHelper();
@@ -26453,10 +26514,8 @@ const LocalazyTransferDownloadService = ({ strapi: strapi2 }) => ({
       }
       await persistCursor();
     };
-    const parsedLocalazyContent = {};
     const strapiContentTypesModels = await StrapiService2.getModels();
-    const jsonFields = [];
-    const entryKeySourceMap = {};
+    const languagesToParse = [];
     for (const [isoLocalazy, keys2] of Object.entries(localazyContent)) {
       const isoStrapi = isoLocalazyToStrapi(isoLocalazy);
       if (!isoStrapi) {
@@ -26465,78 +26524,15 @@ const LocalazyTransferDownloadService = ({ strapi: strapi2 }) => ({
         });
         continue;
       }
-      for (const localazyEntry of keys2) {
-        const key = localazyEntry.key[0];
-        const value = localazyEntry.value;
-        const localazyKeyId = localazyEntry.id;
-        const localazyKeyEvent = localazyEntry.event;
-        const storedEvent = processedKeys[isoStrapi]?.[localazyKeyId];
-        if (storedEvent !== void 0 && localazyKeyEvent !== void 0 && localazyKeyEvent <= storedEvent) {
-          continue;
-        }
-        const parsedKey = StrapiI18nService2.parseLocalazyKey(key);
-        const entryKey = `${isoStrapi}:${parsedKey.uid}:${parsedKey.id}`;
-        if (!entryKeySourceMap[entryKey]) {
-          entryKeySourceMap[entryKey] = [];
-        }
-        entryKeySourceMap[entryKey].push({ lang: isoStrapi, id: localazyKeyId, event: localazyKeyEvent });
-        const modelContentTransferSetup = findSetupModelByCollectionUid(
-          contentTransferSetup,
-          strapiContentTypesModels,
-          parsedKey.uid
-        );
-        if (typeof modelContentTransferSetup !== "undefined") {
-          const shouldSetDownloadedPropertyResult = shouldSetDownloadedProperty(
-            modelContentTransferSetup,
-            parsedKey.rest
-          );
-          if (shouldSetDownloadedPropertyResult === ShouldSetDownloadedPropertyReturnType.NO) {
-            continue;
-          }
-          let parsedKeyRestWithoutComponents = parsedKey.rest;
-          if (shouldSetDownloadedPropertyResult === ShouldSetDownloadedPropertyReturnType.JSON) {
-            const setKey = [isoStrapi, parsedKey.uid, parsedKey.id];
-            let updatedParsedKeyRestWithoutComponents = parsedKeyRestWithoutComponents;
-            let segmentsToAdd = [];
-            for (const segment of parsedKeyRestWithoutComponents) {
-              const hasEntry = get(modelContentTransferSetup, [...segmentsToAdd, segment]);
-              const hasEntryNotFinal = hasEntry && typeof hasEntry !== "boolean";
-              const isComponent2 = parseInt(segment) > 0;
-              if (hasEntryNotFinal || !hasEntry && isComponent2) {
-                segmentsToAdd.push(segment);
-                setKey.push(segment);
-                updatedParsedKeyRestWithoutComponents = updatedParsedKeyRestWithoutComponents.slice(1);
-              } else {
-                break;
-              }
-            }
-            parsedKeyRestWithoutComponents = updatedParsedKeyRestWithoutComponents;
-            let foundJsonFieldIndex = jsonFields.findIndex((jsonField) => {
-              return jsonField.setKey.join() === setKey.join();
-            });
-            if (foundJsonFieldIndex === -1) {
-              jsonFields.push({
-                setKey,
-                jsonKey: parsedKeyRestWithoutComponents[0],
-                jsonValue: {}
-              });
-            }
-            foundJsonFieldIndex = foundJsonFieldIndex === -1 ? jsonFields.length - 1 : foundJsonFieldIndex;
-            const foundJsonField = jsonFields[foundJsonFieldIndex];
-            const restSliced = parsedKeyRestWithoutComponents.slice(1);
-            set(foundJsonField, ["jsonValue", ...restSliced], value);
-            jsonFields[foundJsonFieldIndex] = foundJsonField;
-          }
-          if (shouldSetDownloadedPropertyResult === ShouldSetDownloadedPropertyReturnType.YES) {
-            const setKey = [isoStrapi, parsedKey.uid, parsedKey.id, ...parsedKeyRestWithoutComponents];
-            set(parsedLocalazyContent, setKey, value);
-          }
-        }
-      }
-    }
-    for (const jsonField of jsonFields) {
-      set(parsedLocalazyContent, [...jsonField.setKey, jsonField.jsonKey], jsonField.jsonValue);
-    }
+      languagesToParse.push({ isoStrapi, keys: keys2 });
+    }
+    const { parsedLocalazyContent, entryKeySourceMap } = collectDownloadedContent({
+      languages: languagesToParse,
+      processedKeys,
+      contentTransferSetup,
+      models: strapiContentTypesModels,
+      parseLocalazyKey: (key) => StrapiI18nService2.parseLocalazyKey(key)
+    });
     for (const [isoStrapi, contentTypes2] of Object.entries(parsedLocalazyContent)) {
       for (const [uid, models] of Object.entries(contentTypes2)) {
         const strapiContentTypeModel = strapiContentTypesModels.find((model) => model.uid === uid);
@@ -26720,6 +26716,15 @@ const intlDisplayName = (isoStrapi) => {
   }
   return languageNames.of(isoStrapi.toLowerCase());
 };
+const parseLocalazyKey = (key) => {
+  const split = key.split(/\.(?![^[]*])|\[|\]/);
+  const filteredSplit = split.filter((item) => item !== "");
+  return {
+    uid: `${filteredSplit[0]}.${filteredSplit[1]}`,
+    id: filteredSplit[2],
+    rest: filteredSplit.slice(3)
+  };
+};
 const StrapiI18nService = ({ strapi: strapi2 }) => ({
   async getLocales() {
     return strapi2.plugin("i18n").service("locales").find();
@@ -26747,13 +26752,7 @@ const StrapiI18nService = ({ strapi: strapi2 }) => ({
     }
   },
   parseLocalazyKey(key) {
-    const split = key.split(/\.(?![^[]*])|\[|\]/);
-    const filteredSplit = split.filter((item) => item !== "");
-    return {
-      uid: `${filteredSplit[0]}.${filteredSplit[1]}`,
-      id: filteredSplit[2],
-      rest: filteredSplit.slice(3)
-    };
+    return parseLocalazyKey(key);
   },
   async getEntryInLocale(modelUid, documentId, isoStrapi) {
     const entry = await strapi2.documents(modelUid).findOne({
@@ -26852,18 +26851,6 @@ const LocalazyUploadService = ({ strapi: strapi2 }) => ({
     return file;
   }
 });
-const resetArrayKeysDeep = (object, keysToFilter) => {
-  const sortedKeysToFilter = keysToFilter.sort((a2, b2) => {
-    const aLvl = a2.match(/\./g)?.length || 0;
-    const bLvl = b2.match(/\./g)?.length || 0;
-    return bLvl - aLvl;
-  });
-  for (const key of sortedKeysToFilter) {
-    const part = get(object, key);
-    const filteredPart = part.filter((item) => item !== void 0);
-    set(object, key, filteredPart);
-  }
-};
 const getAttribute = (model, attribute) => {
   if (isEmpty(model)) {
     return void 0;
@@ -26886,22 +26873,63 @@ const isRelation = (attributeObj) => {
 const isBlocks = (attributeObj) => {
   return attributeObj.type === BLOCKS_ATTRIBUTE_TYPE;
 };
+const isJson = (attributeObj) => {
+  return attributeObj.type === "json";
+};
 const findModel = (models, uid) => {
   const model = models.find((model2) => model2.uid === uid);
   return model;
 };
+const arrayItemSegment = (item, index2) => {
+  if (isPlainObject(item) && item.id && item.__component) {
+    return `${item.id};${item.__component}`;
+  }
+  return String(item?.documentId || item?.id || index2);
+};
+const objectIdSegment = (value) => {
+  if (isPlainObject(value) && (value.documentId || value.id)) {
+    return String(value.documentId || value.id);
+  }
+  return void 0;
+};
+const overlayValue = (source, translated) => {
+  if (typeof source === "string") {
+    return typeof translated === "string" ? translated : source;
+  }
+  if (Array.isArray(source)) {
+    return source.map((item, index2) => overlayValue(item, get(translated, [arrayItemSegment(item, index2)])));
+  }
+  if (isPlainObject(source)) {
+    const result = {};
+    for (const [key, value] of Object.entries(source)) {
+      result[key] = key === "id" || key === "documentId" ? value : overlayChild(value, get(translated, [key]));
+    }
+    return result;
+  }
+  return source;
+};
+const overlayChild = (source, translated) => {
+  const idSegment = Array.isArray(source) ? void 0 : objectIdSegment(source);
+  return overlayValue(source, idSegment ? get(translated, [idSegment]) : translated);
+};
+const overlayJsonTranslation = (sourceValue, translated) => {
+  if (sourceValue === void 0 || sourceValue === null) {
+    return void 0;
+  }
+  if (typeof sourceValue !== "object") {
+    return typeof sourceValue === "string" && typeof translated === "string" ? translated : sourceValue;
+  }
+  return overlayChild(cloneDeep(sourceValue), translated);
+};
 const parsedLocalazyEntryToCreateEntry = (models, parsedLocalazyEntry, baseEntry, uid, locale = "") => {
   const createEntry = {};
-  const repeatableComponentsKeystoFilter = [];
   const dynamicZoneComponentKeys = [];
+  const rebuiltFieldPaths = [];
   const toCreateEntry = (entry, model2, key = "", prefix = "", component = "", isRepeatableComponent = false, isDZ = false, isInsideDZ = false) => {
     if (Array.isArray(entry)) {
       Object.entries(entry).forEach(([baseEntryItemId, value]) => {
         if (value !== null) {
           if (component && isRepeatableComponent) {
-            if (!repeatableComponentsKeystoFilter.includes(prefix)) {
-              repeatableComponentsKeystoFilter.push(prefix);
-            }
             const baseEntryRepeatableItemId = parseInt(baseEntryItemId);
             const baseEntryRepeateableGroup = get(baseEntry, prefix);
             if (baseEntryRepeateableGroup !== void 0) {
@@ -26923,9 +26951,6 @@ const parsedLocalazyEntryToCreateEntry = (models, parsedLocalazyEntry, baseEntry
             toCreateEntry(value, model2, `${prefix}`, `${prefix}`);
           }
           if (!component && isRepeatableComponent) {
-            if (!repeatableComponentsKeystoFilter.includes(prefix)) {
-              repeatableComponentsKeystoFilter.push(prefix);
-            }
             const baseEntryRepeatableItemId = parseInt(baseEntryItemId);
             const baseEntryRepeateableGroup = get(baseEntry, prefix);
             if (baseEntryRepeateableGroup !== void 0) {
@@ -27029,11 +27054,20 @@ const parsedLocalazyEntryToCreateEntry = (models, parsedLocalazyEntry, baseEntry
             newPrefixBase = `${dzParamKey}.${baseEntryDZIndex}`;
             newPrefix = `${newPrefixBase}.${objectKey}`;
           }
-          const valueToSet = isBlocks(attribute) ? overlayBlocksTranslation(get(baseEntry, newPrefix), value) : value;
+          const isRebuiltField = isBlocks(attribute) || isJson(attribute);
+          let valueToSet = value;
+          if (isBlocks(attribute)) {
+            valueToSet = overlayBlocksTranslation(get(baseEntry, newPrefix), value);
+          } else if (isJson(attribute)) {
+            valueToSet = overlayJsonTranslation(get(baseEntry, newPrefix), value);
+          }
           if (valueToSet === void 0) {
             return;
           }
           set(createEntry, newPrefix, valueToSet);
+          if (isRebuiltField) {
+            rebuiltFieldPaths.push(newPrefix);
+          }
           if (component) {
             const componentKeyToSet = `${newPrefixBase}.__component`;
             set(createEntry, componentKeyToSet, component);
@@ -27055,8 +27089,59 @@ const parsedLocalazyEntryToCreateEntry = (models, parsedLocalazyEntry, baseEntry
   if (locale) {
     createEntry.locale = locale;
   }
-  resetArrayKeysDeep(createEntry, repeatableComponentsKeystoFilter);
-  return { createEntry, dynamicZoneComponentKeys };
+  return { createEntry, dynamicZoneComponentKeys, rebuiltFieldPaths };
+};
+const isMediaObject = (obj) => {
+  if (typeof obj !== "object" || obj === null) return false;
+  return "url" in obj && "name" in obj && "ext" in obj && ("mime" in obj || "mimeType" in obj) && typeof obj.url === "string" && typeof obj.name === "string" && typeof obj.ext === "string";
+};
+const dropPropertyDeepWithSkip = (obj, propertyName, isRoot = true, skipPredicates = []) => {
+  if (Array.isArray(obj)) {
+    return obj.filter((item) => {
+      if (skipPredicates.length > 0) {
+        return true;
+      }
+      return isRoot || !(typeof item === "object" && item !== null && propertyName in item);
+    }).map(
+      (item) => typeof item === "object" && item !== null ? dropPropertyDeepWithSkip(item, propertyName, false, skipPredicates) : item
+    );
+  }
+  if (typeof obj === "object" && obj !== null) {
+    const shouldSkip = skipPredicates.some((predicate) => predicate(obj));
+    if (shouldSkip) {
+      const result2 = {};
+      for (const key in obj) {
+        if (key === propertyName) {
+          result2[key] = obj[key];
+        } else {
+          result2[key] = typeof obj[key] === "object" && obj[key] !== null ? dropPropertyDeepWithSkip(obj[key], propertyName, false, skipPredicates) : obj[key];
+        }
+      }
+      return result2;
+    }
+    const result = {};
+    for (const key in obj) {
+      if (key === propertyName && !isRoot) {
+        continue;
+      }
+      result[key] = typeof obj[key] === "object" && obj[key] !== null ? dropPropertyDeepWithSkip(obj[key], propertyName, false, skipPredicates) : obj[key];
+    }
+    return result;
+  }
+  return obj;
+};
+const dropDocumentIdExceptMedia = (obj) => {
+  return dropPropertyDeepWithSkip(obj, "documentId", true, [isMediaObject]);
+};
+const OMIT_KEYS = ["locale", "localizations", "createdAt", "createdBy", "updatedAt", "updatedBy", "publishedAt"];
+const buildLocalizedCreateEntry = (models, translatedModel, baseEntry, uid, isoStrapi) => {
+  const { createEntry } = parsedLocalazyEntryToCreateEntry(models, translatedModel, baseEntry, uid, isoStrapi);
+  const filteredBaseEntry = dropDocumentIdExceptMedia(omitDeep(baseEntry, OMIT_KEYS));
+  let mergedCreateEntry = {};
+  merge(mergedCreateEntry, filteredBaseEntry, createEntry);
+  mergedCreateEntry = omitDeep(mergedCreateEntry, OMIT_KEYS);
+  mergedCreateEntry.locale = isoStrapi;
+  return mergedCreateEntry;
 };
 const doesExistInPopulatedLocalizedEntry = (val) => {
   if (Array.isArray(val)) {
@@ -27095,17 +27180,17 @@ const populateCreateUpdateEntryWithBaseEntry = async (models, createUpdateEntry,
           }
         }
       } else if (!component && isRepeatableComponent && isDZ) {
-        Object.entries(partialBaseEntry).forEach(async ([partialBaseEntryItemIndex, partialBaseEntryItem]) => {
+        for (const [partialBaseEntryItemIndex, partialBaseEntryItem] of Object.entries(partialBaseEntry)) {
           const component2 = partialBaseEntryItem.__component;
           const model3 = findModel(models, component2);
           const newPrefix = `${prefix}.${partialBaseEntryItemIndex}`;
           await populateEntry(partialBaseEntryItem, model3, partialBaseEntryItemIndex, newPrefix);
-        });
+        }
       } else if (component && isRepeatableComponent) {
-        Object.entries(partialBaseEntry).forEach(async ([partialBaseEntryItemIndex, partialBaseEntryItem]) => {
+        for (const [partialBaseEntryItemIndex, partialBaseEntryItem] of Object.entries(partialBaseEntry)) {
           const newPrefix = `${prefix}.${partialBaseEntryItemIndex}`;
           await populateEntry(partialBaseEntryItem, model2, partialBaseEntryItemIndex, newPrefix);
-        });
+        }
       }
     } else if (typeof partialBaseEntry === "object") {
       if (partialBaseEntry === null) {
@@ -27218,7 +27303,7 @@ const populateCreateUpdateEntryWithBaseEntry = async (models, createUpdateEntry,
             } else {
               set(populatedEntry, newPrefix, value);
             }
-          } else {
+          } else if (!isBlocks(attribute) && !isJson(attribute)) {
             await populateEntry(value, model2, objectKey2, newPrefix);
           }
         }
@@ -27240,15 +27325,80 @@ const populateCreateUpdateEntryWithBaseEntry = async (models, createUpdateEntry,
   await populateEntry(baseEntry, model);
   return populatedEntry;
 };
+const dropComponentIds = (models, item, model) => {
+  if (!isPlainObject(item)) {
+    return;
+  }
+  delete item.id;
+  for (const [name2, attribute] of Object.entries(model?.attributes || {})) {
+    const value = item[name2];
+    if (attribute.type === "component") {
+      const componentModel = findModel(models, attribute.component);
+      (Array.isArray(value) ? value : [value]).forEach((child) => dropComponentIds(models, child, componentModel));
+    } else if (attribute.type === "dynamiczone" && Array.isArray(value)) {
+      value.forEach((child) => dropComponentIds(models, child, findModel(models, child?.__component)));
+    }
+  }
+};
+const asNewComponent = (models, sourceItem, model) => {
+  const copy = cloneDeep(sourceItem);
+  dropComponentIds(models, copy, model);
+  return copy;
+};
+const alignLocalizedEntryToSource = (models, localizedEntry, sourceEntry, model, downloadedEntry) => {
+  if (!isPlainObject(localizedEntry) || !isPlainObject(sourceEntry) || !isPlainObject(downloadedEntry)) {
+    return localizedEntry;
+  }
+  const aligned = { ...localizedEntry };
+  for (const [name2, attribute] of Object.entries(model?.attributes || {})) {
+    const source = sourceEntry[name2];
+    const current = localizedEntry[name2];
+    const downloaded = downloadedEntry[name2];
+    if (downloaded === void 0 || downloaded === null || current === void 0) {
+      continue;
+    }
+    if (attribute.type === "component") {
+      const componentModel = findModel(models, attribute.component);
+      if (attribute.repeatable) {
+        if (!Array.isArray(source)) continue;
+        const currentItems = Array.isArray(current) ? current : [];
+        aligned[name2] = currentItems.length === source.length ? currentItems.map(
+          (item, index2) => alignLocalizedEntryToSource(models, item, source[index2], componentModel, downloaded[index2])
+        ) : source.map((item) => asNewComponent(models, item, componentModel));
+      } else if (isPlainObject(source) && isPlainObject(current)) {
+        aligned[name2] = alignLocalizedEntryToSource(models, current, source, componentModel, downloaded);
+      }
+    } else if (attribute.type === "dynamiczone") {
+      if (!Array.isArray(source)) continue;
+      const currentItems = Array.isArray(current) ? current : [];
+      const sameLayout = currentItems.length === source.length && currentItems.every((item, index2) => item?.__component === source[index2]?.__component);
+      aligned[name2] = sameLayout ? currentItems.map(
+        (item, index2) => alignLocalizedEntryToSource(
+          models,
+          item,
+          source[index2],
+          findModel(models, item.__component),
+          downloaded[index2]
+        )
+      ) : source.map((item) => asNewComponent(models, item, findModel(models, item.__component)));
+    }
+  }
+  return aligned;
+};
 const parsedLocalazyEntryToUpdateEntry = async (allModels, localazyEntry, fullyPopulatedLocalizedEntry, currentEntry, baseEntry, uid, locale) => {
-  const { createEntry, dynamicZoneComponentKeys } = parsedLocalazyEntryToCreateEntry(
+  const { createEntry, dynamicZoneComponentKeys, rebuiltFieldPaths } = parsedLocalazyEntryToCreateEntry(
     allModels,
     localazyEntry,
     baseEntry,
     uid
   );
+  const model = findModel(allModels, uid);
+  const alignedCurrentEntry = alignLocalizedEntryToSource(allModels, currentEntry, baseEntry, model, createEntry);
   let updateEntry = {};
-  merge(updateEntry, currentEntry, createEntry);
+  merge(updateEntry, alignedCurrentEntry, createEntry);
+  for (const rebuiltFieldPath of rebuiltFieldPaths) {
+    set(updateEntry, rebuiltFieldPath, cloneDeep(get(createEntry, rebuiltFieldPath)));
+  }
   updateEntry = omitDeep(updateEntry, [
     // '__component', // do not omit the __component
     "locale",
@@ -27272,16 +27422,19 @@ const parsedLocalazyEntryToUpdateEntry = async (allModels, localazyEntry, fullyP
     "updatedBy",
     "publishedAt"
   ]);
-  const filteredFullyPopulatedLocalizedEntry = omitDeep(fullyPopulatedLocalizedEntry, [
-    // "__component", // do not omit the __component
-    "locale",
-    "localizations",
-    "createdAt",
-    "createdBy",
-    "updatedAt",
-    "updatedBy",
-    "publishedAt"
-  ]);
+  const filteredFullyPopulatedLocalizedEntry = omitDeep(
+    alignLocalizedEntryToSource(allModels, fullyPopulatedLocalizedEntry, baseEntry, model, createEntry),
+    [
+      // "__component", // do not omit the __component
+      "locale",
+      "localizations",
+      "createdAt",
+      "createdBy",
+      "updatedAt",
+      "updatedBy",
+      "publishedAt"
+    ]
+  );
   const populatedEntry = await populateCreateUpdateEntryWithBaseEntry(
     allModels,
     updateEntry,
@@ -27292,65 +27445,16 @@ const parsedLocalazyEntryToUpdateEntry = async (allModels, localazyEntry, fullyP
   );
   return populatedEntry;
 };
-const isMediaObject = (obj) => {
-  if (typeof obj !== "object" || obj === null) return false;
-  return "url" in obj && "name" in obj && "ext" in obj && ("mime" in obj || "mimeType" in obj) && typeof obj.url === "string" && typeof obj.name === "string" && typeof obj.ext === "string";
-};
-const dropPropertyDeepWithSkip = (obj, propertyName, isRoot = true, skipPredicates = []) => {
-  if (Array.isArray(obj)) {
-    return obj.filter((item) => {
-      if (skipPredicates.length > 0) {
-        return true;
-      }
-      return isRoot || !(typeof item === "object" && item !== null && propertyName in item);
-    }).map(
-      (item) => typeof item === "object" && item !== null ? dropPropertyDeepWithSkip(item, propertyName, false, skipPredicates) : item
-    );
-  }
-  if (typeof obj === "object" && obj !== null) {
-    const shouldSkip = skipPredicates.some((predicate) => predicate(obj));
-    if (shouldSkip) {
-      const result2 = {};
-      for (const key in obj) {
-        if (key === propertyName) {
-          result2[key] = obj[key];
-        } else {
-          result2[key] = typeof obj[key] === "object" && obj[key] !== null ? dropPropertyDeepWithSkip(obj[key], propertyName, false, skipPredicates) : obj[key];
-        }
-      }
-      return result2;
-    }
-    const result = {};
-    for (const key in obj) {
-      if (key === propertyName && !isRoot) {
-        continue;
-      }
-      result[key] = typeof obj[key] === "object" && obj[key] !== null ? dropPropertyDeepWithSkip(obj[key], propertyName, false, skipPredicates) : obj[key];
-    }
-    return result;
-  }
-  return obj;
-};
-const dropDocumentIdExceptMedia = (obj) => {
-  return dropPropertyDeepWithSkip(obj, "documentId", true, [isMediaObject]);
-};
 const StrapiLocalazyI18nService = ({ strapi: strapi2 }) => ({
   async createEntry(uid, strapiContentTypesModels, translatedModel, baseEntry, isoStrapi) {
     const StrapiI18nService2 = getStrapiI18nService();
-    const { createEntry } = parsedLocalazyEntryToCreateEntry(
+    const mergedCreateEntry = buildLocalizedCreateEntry(
       strapiContentTypesModels,
       translatedModel,
       baseEntry,
       uid,
       isoStrapi
     );
-    const omitKeys = ["locale", "localizations", "createdAt", "createdBy", "updatedAt", "updatedBy", "publishedAt"];
-    let filteredBaseEntry = omitDeep(baseEntry, omitKeys);
-    filteredBaseEntry = dropDocumentIdExceptMedia(filteredBaseEntry);
-    let mergedCreateEntry = {};
-    merge(mergedCreateEntry, filteredBaseEntry, createEntry);
-    mergedCreateEntry = omitDeep(mergedCreateEntry, omitKeys);
-    mergedCreateEntry.locale = isoStrapi;
     const createdEntry = await StrapiI18nService2.createLocalizationForAnExistingEntry(
       uid,
       baseEntry,