@localazy/strapi-plugin 1.6.0 → 1.7.1

package/dist/server/index.mjs

@@ -20520,7 +20520,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.6.0";
+const version = "1.7.1";
 const description = "The official Strapi Plugin by Localazy.";
 const keywords = [
   "strapi",
@@ -22038,7 +22038,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);
@@ -25611,182 +25611,6 @@ const PluginSettingsService = ({ strapi: strapi2 }) => ({
     return cursor;
   }
 });
-const LocalazyTransferUploadService = ({ strapi: strapi2 }) => ({
-  async upload({ notificationService }) {
-    console.time("upload");
-    await notificationService.emit(EventType.UPLOAD, {
-      message: "Upload started"
-    });
-    const activityLogsService = getActivityLogsService();
-    const sessionId = await activityLogsService.startSession("upload", "Strapi User");
-    await activityLogsService.addEntry(sessionId, "Upload started");
-    let success = true;
-    const StrapiService2 = getStrapiService();
-    const StrapiI18nService2 = getStrapiI18nService();
-    const LocalazyUploadService2 = getLocalazyUploadService();
-    const EntryExclusionService2 = getEntryExclusionService();
-    const contentTransferSetup = await getPluginSettingsService().getContentTransferSetup();
-    if (!contentTransferSetup.has_setup) {
-      const message = "Content transfer setup is not set up.";
-      success = false;
-      await notificationService.emit(EventType.UPLOAD_FINISHED, {
-        success,
-        message
-      });
-      await activityLogsService.addEntry(sessionId, message);
-      await activityLogsService.finishSession(sessionId, "failed", message);
-      strapi2.log.info(message);
-      return;
-    }
-    const { setup: setup2 } = contentTransferSetup;
-    const collectionsNames = getCollectionsNames(setup2);
-    const models = await StrapiService2.getModels();
-    const strapiDefaultLocaleCode = await StrapiI18nService2.getDefaultLocaleCode();
-    const attemptedTuples = [];
-    let pickedFlattenStrapiContent = {};
-    for (const collectionName of collectionsNames) {
-      const currentModel = models.find((model) => model.collectionName === collectionName);
-      const modelUid = currentModel.uid;
-      if (!currentModel) {
-        strapi2.log.warn(`Model with uid ${modelUid} is not found.`);
-        continue;
-      }
-      const transferSetupModel = findSetupModelByCollectionName(setup2, collectionName);
-      if (!isCollectionTransferEnabled(setup2, collectionName)) {
-        const message2 = `Collection ${collectionName} transfer is disabled.`;
-        await notificationService.emit(EventType.UPLOAD, {
-          message: message2
-        });
-        await activityLogsService.addEntry(sessionId, message2);
-        strapi2.log.info(message2);
-        continue;
-      }
-      const currentTransferSetupModel = transferSetupModel[collectionName];
-      const pickPaths = getPickPathsWithComponents(currentTransferSetupModel);
-      if (!pickPaths.length) {
-        const message2 = `No fields for collection ${collectionName} transfer are enabled.`;
-        await notificationService.emit(EventType.UPLOAD, {
-          message: message2
-        });
-        await activityLogsService.addEntry(sessionId, message2);
-        strapi2.log.warn(message2);
-        continue;
-      }
-      const pickPathsWithUid = pickPaths.map((pickPath) => `${modelUid}.${pickPath}`);
-      let entries = await strapi2.documents(modelUid).findMany({
-        locUploadPLevel: 6,
-        status: "draft"
-      });
-      if (!entries.length) {
-        strapi2.log.info(`No entries found for model ${modelUid}`);
-        continue;
-      }
-      const excludedEntries = await EntryExclusionService2.getContentTypeExclusions(modelUid);
-      const filteredEntries = [];
-      for (const entry of entries) {
-        const isExcluded = excludedEntries.includes(entry.documentId);
-        if (!isExcluded) {
-          filteredEntries.push(entry);
-        }
-      }
-      entries = filteredEntries;
-      if (!entries.length) {
-        const message2 = `All entries for model ${collectionName} are excluded from translation`;
-        await notificationService.emit(EventType.UPLOAD, {
-          message: message2
-        });
-        await activityLogsService.addEntry(sessionId, message2);
-        strapi2.log.info(message2);
-        continue;
-      }
-      const message = `Excluding ${excludedEntries.length} entries for model ${collectionName} from upload. Entries to translate: ${entries.length}.`;
-      await notificationService.emit(EventType.UPLOAD, {
-        message
-      });
-      await activityLogsService.addEntry(sessionId, message);
-      strapi2.log.info(message);
-      if (strapiDefaultLocaleCode) {
-        for (const entry of entries) {
-          attemptedTuples.push({
-            uid: modelUid,
-            documentId: entry.documentId,
-            locale: strapiDefaultLocaleCode
-          });
-        }
-      }
-      entries = omitDeep(entries, ["locale", "createdAt", "updatedAt", "publishedAt"]);
-      entries.forEach((entry) => {
-        const flatten = flattenObject({
-          [modelUid]: entry
-        });
-        const pickedFlatten = pickEntries(flatten, pickPathsWithUid);
-        pickedFlattenStrapiContent = {
-          ...pickedFlattenStrapiContent,
-          ...pickedFlatten
-        };
-      });
-      const characterLimitsMetadata = getCharacterLimitsMetadata(pickedFlattenStrapiContent, modelUid);
-      pickedFlattenStrapiContent = {
-        ...pickedFlattenStrapiContent,
-        ...characterLimitsMetadata
-      };
-    }
-    const localazyLocaleCode = strapiDefaultLocaleCode ? isoStrapiToLocalazy(strapiDefaultLocaleCode) : config.default.LOCALAZY_DEFAULT_LOCALE;
-    const importFile = LocalazyUploadService2.createImportFileRepresentation(
-      localazyLocaleCode,
-      pickedFlattenStrapiContent
-    );
-    const uploadConfig = {
-      contentOptions: {
-        type: config.default.LOCALAZY_DEFAULT_FILE_EXTENSION
-      },
-      i18nOptions: { deprecate: "file" },
-      fileOptions: {
-        name: config.default.LOCALAZY_DEFAULT_FILE_NAME,
-        path: config.default.LOCALAZY_DEFAULT_FILE_PATH
-      }
-    };
-    await notificationService.emit(EventType.UPLOAD, {
-      message: "Uploading collections to Localazy..."
-    });
-    await activityLogsService.addEntry(sessionId, "Uploading collections to Localazy...");
-    try {
-      await LocalazyUploadService2.upload(importFile, uploadConfig);
-      await activityLogsService.recordAttemptedEntries(
-        sessionId,
-        attemptedTuples.map((t3) => ({ ...t3, status: "success" }))
-      );
-    } catch (error) {
-      success = false;
-      const errorMessage = `Upload to Localazy failed: ${error instanceof Error ? error.message : String(error)}`;
-      strapi2.log.error(errorMessage);
-      await notificationService.emit(EventType.UPLOAD_FINISHED, {
-        success,
-        message: errorMessage
-      });
-      await activityLogsService.addEntry(sessionId, errorMessage);
-      await activityLogsService.recordAttemptedEntries(
-        sessionId,
-        attemptedTuples.map((t3) => ({ ...t3, status: "failed", errorMessage }))
-      );
-      await activityLogsService.finishSession(sessionId, "failed", errorMessage);
-      console.timeEnd("upload");
-      return;
-    }
-    strapi2.log.info("Upload finished in");
-    await notificationService.emit(EventType.UPLOAD_FINISHED, {
-      success,
-      message: "Upload finished"
-    });
-    await activityLogsService.addEntry(sessionId, "Upload finished");
-    await activityLogsService.finishSession(
-      sessionId,
-      success ? "completed" : "failed",
-      success ? "Upload completed successfully" : "Upload finished with errors"
-    );
-    console.timeEnd("upload");
-  }
-});
 var symbolTag$2 = "[object Symbol]";
 function isSymbol(value) {
   return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag$2;
@@ -26093,20 +25917,274 @@ function baseSet(object, path, value, customizer) {
         newValue = isObject(objValue) ? objValue : isIndex(path[index2 + 1]) ? [] : {};
       }
     }
-    assignValue(nested, key, newValue);
-    nested = nested[key];
+    assignValue(nested, key, newValue);
+    nested = nested[key];
+  }
+  return object;
+}
+function set(object, path, value) {
+  return object == null ? object : baseSet(object, path, value);
+}
+const BLOCKS_ATTRIBUTE_TYPE = "blocks";
+const projectBlocksFields = (entry, model, getModel) => {
+  const cloned = cloneDeep(entry);
+  walkAndProject(cloned, model, getModel);
+  return cloned;
+};
+const walkAndProject = (value, model, getModel) => {
+  if (!value || !model?.attributes) {
+    return;
+  }
+  for (const [attributeName, attribute] of Object.entries(model.attributes)) {
+    const fieldValue = value[attributeName];
+    if (fieldValue === void 0 || fieldValue === null) {
+      continue;
+    }
+    if (attribute.type === BLOCKS_ATTRIBUTE_TYPE) {
+      value[attributeName] = projectBlocksValue(fieldValue);
+    } else if (attribute.type === "component") {
+      const componentModel = getModel(attribute.component);
+      if (attribute.repeatable && Array.isArray(fieldValue)) {
+        fieldValue.forEach((item) => walkAndProject(item, componentModel, getModel));
+      } else if (isPlainObject(fieldValue)) {
+        walkAndProject(fieldValue, componentModel, getModel);
+      }
+    } else if (attribute.type === "dynamiczone" && Array.isArray(fieldValue)) {
+      fieldValue.forEach((item) => {
+        if (item?.__component) {
+          walkAndProject(item, getModel(item.__component), getModel);
+        }
+      });
+    }
+  }
+};
+const projectBlocksValue = (nodes) => {
+  if (!Array.isArray(nodes)) {
+    return nodes;
+  }
+  return nodes.map(projectNode);
+};
+const projectNode = (node) => {
+  if (!isPlainObject(node)) {
+    return {};
+  }
+  const projected = {};
+  if (typeof node.text === "string") {
+    projected.text = node.text;
+  }
+  if (Array.isArray(node.children)) {
+    projected.children = node.children.map(projectNode);
+  }
+  return projected;
+};
+const overlayBlocksTranslation = (sourceAst, translated) => {
+  if (!Array.isArray(sourceAst)) {
+    return void 0;
+  }
+  return sourceAst.map((node, index2) => overlayNode(node, get(translated, [String(index2)])));
+};
+const overlayNode = (node, translatedNode) => {
+  if (!isPlainObject(node)) {
+    return cloneDeep(node);
+  }
+  if (typeof node.text === "string") {
+    const translatedText = isPlainObject(translatedNode) ? translatedNode.text : void 0;
+    return typeof translatedText === "string" ? { ...node, text: translatedText } : cloneDeep(node);
+  }
+  if (Array.isArray(node.children)) {
+    return {
+      ...node,
+      children: node.children.map(
+        (child, index2) => overlayNode(child, translatedNode ? get(translatedNode, ["children", String(index2)]) : void 0)
+      )
+    };
+  }
+  return cloneDeep(node);
+};
+const LocalazyTransferUploadService = ({ strapi: strapi2 }) => ({
+  async upload({ notificationService }) {
+    console.time("upload");
+    await notificationService.emit(EventType.UPLOAD, {
+      message: "Upload started"
+    });
+    const activityLogsService = getActivityLogsService();
+    const sessionId = await activityLogsService.startSession("upload", "Strapi User");
+    await activityLogsService.addEntry(sessionId, "Upload started");
+    let success = true;
+    const StrapiService2 = getStrapiService();
+    const StrapiI18nService2 = getStrapiI18nService();
+    const LocalazyUploadService2 = getLocalazyUploadService();
+    const EntryExclusionService2 = getEntryExclusionService();
+    const contentTransferSetup = await getPluginSettingsService().getContentTransferSetup();
+    if (!contentTransferSetup.has_setup) {
+      const message = "Content transfer setup is not set up.";
+      success = false;
+      await notificationService.emit(EventType.UPLOAD_FINISHED, {
+        success,
+        message
+      });
+      await activityLogsService.addEntry(sessionId, message);
+      await activityLogsService.finishSession(sessionId, "failed", message);
+      strapi2.log.info(message);
+      return;
+    }
+    const { setup: setup2 } = contentTransferSetup;
+    const collectionsNames = getCollectionsNames(setup2);
+    const models = await StrapiService2.getModels();
+    const strapiDefaultLocaleCode = await StrapiI18nService2.getDefaultLocaleCode();
+    const attemptedTuples = [];
+    let pickedFlattenStrapiContent = {};
+    for (const collectionName of collectionsNames) {
+      const currentModel = models.find((model) => model.collectionName === collectionName);
+      const modelUid = currentModel.uid;
+      if (!currentModel) {
+        strapi2.log.warn(`Model with uid ${modelUid} is not found.`);
+        continue;
+      }
+      const transferSetupModel = findSetupModelByCollectionName(setup2, collectionName);
+      if (!isCollectionTransferEnabled(setup2, collectionName)) {
+        const message2 = `Collection ${collectionName} transfer is disabled.`;
+        await notificationService.emit(EventType.UPLOAD, {
+          message: message2
+        });
+        await activityLogsService.addEntry(sessionId, message2);
+        strapi2.log.info(message2);
+        continue;
+      }
+      const currentTransferSetupModel = transferSetupModel[collectionName];
+      const pickPaths = getPickPathsWithComponents(currentTransferSetupModel);
+      if (!pickPaths.length) {
+        const message2 = `No fields for collection ${collectionName} transfer are enabled.`;
+        await notificationService.emit(EventType.UPLOAD, {
+          message: message2
+        });
+        await activityLogsService.addEntry(sessionId, message2);
+        strapi2.log.warn(message2);
+        continue;
+      }
+      const pickPathsWithUid = pickPaths.map((pickPath) => `${modelUid}.${pickPath}`);
+      let entries = await strapi2.documents(modelUid).findMany({
+        locUploadPLevel: 6,
+        status: "draft"
+      });
+      if (!entries.length) {
+        strapi2.log.info(`No entries found for model ${modelUid}`);
+        continue;
+      }
+      const excludedEntries = await EntryExclusionService2.getContentTypeExclusions(modelUid);
+      const filteredEntries = [];
+      for (const entry of entries) {
+        const isExcluded = excludedEntries.includes(entry.documentId);
+        if (!isExcluded) {
+          filteredEntries.push(entry);
+        }
+      }
+      entries = filteredEntries;
+      if (!entries.length) {
+        const message2 = `All entries for model ${collectionName} are excluded from translation`;
+        await notificationService.emit(EventType.UPLOAD, {
+          message: message2
+        });
+        await activityLogsService.addEntry(sessionId, message2);
+        strapi2.log.info(message2);
+        continue;
+      }
+      const message = `Excluding ${excludedEntries.length} entries for model ${collectionName} from upload. Entries to translate: ${entries.length}.`;
+      await notificationService.emit(EventType.UPLOAD, {
+        message
+      });
+      await activityLogsService.addEntry(sessionId, message);
+      strapi2.log.info(message);
+      if (strapiDefaultLocaleCode) {
+        for (const entry of entries) {
+          attemptedTuples.push({
+            uid: modelUid,
+            documentId: entry.documentId,
+            locale: strapiDefaultLocaleCode
+          });
+        }
+      }
+      entries = omitDeep(entries, ["locale", "createdAt", "updatedAt", "publishedAt"]);
+      entries.forEach((entry) => {
+        const projectedEntry = projectBlocksFields(
+          entry,
+          strapi2.getModel(modelUid),
+          (uid) => strapi2.getModel(uid)
+        );
+        const flatten = flattenObject({
+          [modelUid]: projectedEntry
+        });
+        const pickedFlatten = pickEntries(flatten, pickPathsWithUid);
+        pickedFlattenStrapiContent = {
+          ...pickedFlattenStrapiContent,
+          ...pickedFlatten
+        };
+      });
+      const characterLimitsMetadata = getCharacterLimitsMetadata(pickedFlattenStrapiContent, modelUid);
+      pickedFlattenStrapiContent = {
+        ...pickedFlattenStrapiContent,
+        ...characterLimitsMetadata
+      };
+    }
+    const localazyLocaleCode = strapiDefaultLocaleCode ? isoStrapiToLocalazy(strapiDefaultLocaleCode) : config.default.LOCALAZY_DEFAULT_LOCALE;
+    const importFile = LocalazyUploadService2.createImportFileRepresentation(
+      localazyLocaleCode,
+      pickedFlattenStrapiContent
+    );
+    const uploadConfig = {
+      contentOptions: {
+        type: config.default.LOCALAZY_DEFAULT_FILE_EXTENSION
+      },
+      i18nOptions: { deprecate: "file" },
+      fileOptions: {
+        name: config.default.LOCALAZY_DEFAULT_FILE_NAME,
+        path: config.default.LOCALAZY_DEFAULT_FILE_PATH
+      }
+    };
+    await notificationService.emit(EventType.UPLOAD, {
+      message: "Uploading collections to Localazy..."
+    });
+    await activityLogsService.addEntry(sessionId, "Uploading collections to Localazy...");
+    try {
+      await LocalazyUploadService2.upload(importFile, uploadConfig);
+      await activityLogsService.recordAttemptedEntries(
+        sessionId,
+        attemptedTuples.map((t3) => ({ ...t3, status: "success" }))
+      );
+    } catch (error) {
+      success = false;
+      const errorMessage = `Upload to Localazy failed: ${error instanceof Error ? error.message : String(error)}`;
+      strapi2.log.error(errorMessage);
+      await notificationService.emit(EventType.UPLOAD_FINISHED, {
+        success,
+        message: errorMessage
+      });
+      await activityLogsService.addEntry(sessionId, errorMessage);
+      await activityLogsService.recordAttemptedEntries(
+        sessionId,
+        attemptedTuples.map((t3) => ({ ...t3, status: "failed", errorMessage }))
+      );
+      await activityLogsService.finishSession(sessionId, "failed", errorMessage);
+      console.timeEnd("upload");
+      return;
+    }
+    strapi2.log.info("Upload finished in");
+    await notificationService.emit(EventType.UPLOAD_FINISHED, {
+      success,
+      message: "Upload finished"
+    });
+    await activityLogsService.addEntry(sessionId, "Upload finished");
+    await activityLogsService.finishSession(
+      sessionId,
+      success ? "completed" : "failed",
+      success ? "Upload completed successfully" : "Upload finished with errors"
+    );
+    console.timeEnd("upload");
   }
-  return object;
-}
-function set(object, path, value) {
-  return object == null ? object : baseSet(object, path, value);
-}
+});
 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];
 };
@@ -26126,52 +26204,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();
@@ -26358,10 +26500,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) {
@@ -26370,78 +26510,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);
@@ -26625,6 +26702,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();
@@ -26652,13 +26738,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({
@@ -26757,18 +26837,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;
@@ -26788,22 +26856,66 @@ const isRepeatable = (attributeObj) => {
 const isRelation = (attributeObj) => {
   return attributeObj.type === "relation" && attributeObj.target !== "plugin::upload.file";
 };
+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) {
@@ -26825,9 +26937,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) {
@@ -26931,7 +27040,20 @@ const parsedLocalazyEntryToCreateEntry = (models, parsedLocalazyEntry, baseEntry
             newPrefixBase = `${dzParamKey}.${baseEntryDZIndex}`;
             newPrefix = `${newPrefixBase}.${objectKey}`;
           }
-          set(createEntry, newPrefix, 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);
@@ -26953,8 +27075,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)) {
@@ -26993,17 +27166,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) {
@@ -27116,7 +27289,7 @@ const populateCreateUpdateEntryWithBaseEntry = async (models, createUpdateEntry,
             } else {
               set(populatedEntry, newPrefix, value);
             }
-          } else {
+          } else if (!isBlocks(attribute) && !isJson(attribute)) {
             await populateEntry(value, model2, objectKey2, newPrefix);
           }
         }
@@ -27138,15 +27311,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",
@@ -27170,16 +27408,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,
@@ -27190,65 +27431,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,