@translationstudio/translationstudio-strapi-extension 1.0.0 → 1.0.2

package/dist/server/index.js

@@ -0,0 +1,1038 @@
+"use strict";
+const bootstrap = ({ strapi: strapi2 }) => {
+};
+const destroy = ({ strapi: strapi2 }) => {
+};
+const register = ({ strapi: strapi2 }) => {
+};
+const config = {
+  default: {},
+  validator() {
+  }
+};
+const contentTypes = {};
+const controller = ({ strapi: strapi2 }) => ({
+  async validateToken(ctx) {
+    const authHeader = ctx.request.header.authorization;
+    if (!authHeader) {
+      ctx.status = 401;
+      ctx.body = { error: "Missing authorization header" };
+      return false;
+    }
+    const storedToken = await strapi2.plugin("translationstudio").service("service").getToken();
+    if (!storedToken?.token || authHeader !== storedToken.token) {
+      ctx.status = 401;
+      ctx.body = { error: "Invalid token" };
+      return false;
+    }
+    return true;
+  },
+  async getLicense(ctx) {
+    const result = await strapi2.plugin("translationstudio").service("service").getLicense();
+    if (result.license) {
+      ctx.status = 200;
+    } else {
+      ctx.status = 404;
+    }
+    ctx.body = result;
+  },
+  async setLicense(ctx) {
+    const license = ctx.request.body.license;
+    const result = await strapi2.plugin("translationstudio").service("service").setLicense(license);
+    if (result.success) {
+      ctx.status = 200;
+    } else {
+      ctx.status = 500;
+    }
+    ctx.body = result;
+  },
+  async getToken(ctx) {
+    const result = await strapi2.plugin("translationstudio").service("service").getToken();
+    if (result.token) {
+      ctx.status = 200;
+    } else {
+      ctx.status = 404;
+    }
+    ctx.body = result;
+  },
+  async generateToken(ctx) {
+    const result = await strapi2.plugin("translationstudio").service("service").generateToken();
+    ctx.status = 200;
+    ctx.body = result;
+  },
+  async getLanguageOptions(ctx) {
+    const result = await strapi2.plugin("translationstudio").service("service").getLanguageOptions();
+    ctx.status = 200;
+    ctx.body = result;
+  },
+  async requestTranslation(ctx) {
+    const payload = ctx.request.body;
+    const result = await strapi2.plugin("translationstudio").service("service").requestTranslation(payload);
+    ctx.body = result;
+  },
+  async exportData(ctx) {
+    if (!await this.validateToken(ctx)) {
+      ctx.status = 400;
+      return;
+    }
+    const payload = JSON.parse(ctx.request.body);
+    const result = await strapi2.plugin("translationstudio").service("service").exportData(payload);
+    ctx.status = 200;
+    ctx.body = [{ fields: result }];
+  },
+  async importData(ctx) {
+    if (!await this.validateToken(ctx)) {
+      ctx.status = 400;
+      return;
+    }
+    const payload = JSON.parse(ctx.request.body);
+    const result = await strapi2.plugin("translationstudio").service("service").importData(payload);
+    ctx.body = result;
+  },
+  async ping(ctx) {
+    const result = await strapi2.plugin("translationstudio").service("service").ping();
+    ctx.status = 204;
+    ctx.body = result;
+  },
+  async getLanguages(ctx) {
+    if (!await this.validateToken(ctx)) {
+      ctx.status = 400;
+      return;
+    }
+    const result = await strapi2.plugin("translationstudio").service("service").getLanguages();
+    ctx.status = 200;
+    ctx.body = result;
+  },
+  async getEmail(ctx) {
+    const result = await strapi2.plugin("translationstudio").service("service").getEmail(ctx);
+    ctx.body = result;
+  },
+  async getEntryData(ctx) {
+    const { uid, locale } = ctx.request.body;
+    if (!uid) {
+      return ctx.badRequest("Missing uid parameter");
+    }
+    try {
+      const [contentTypeID, entryID] = uid.split("#");
+      const entry = await strapi2.plugin("translationstudio").service("service").getEntryData(contentTypeID, entryID, locale);
+      return entry;
+    } catch (error) {
+      return ctx.badRequest("Failed to get entry data", { error: error.message });
+    }
+  }
+});
+const controllers = {
+  controller
+};
+const middlewares = {};
+const policies = {};
+const routes = [
+  {
+    method: "POST",
+    path: "/setLicense",
+    handler: "controller.setLicense",
+    config: {
+      policies: []
+    }
+  },
+  {
+    method: "GET",
+    path: "/getLicense",
+    handler: "controller.getLicense",
+    config: {
+      policies: []
+    }
+  },
+  {
+    method: "GET",
+    path: "/getToken",
+    handler: "controller.getToken",
+    config: {
+      policies: []
+    }
+  },
+  {
+    method: "POST",
+    path: "/generateToken",
+    handler: "controller.generateToken",
+    config: {
+      policies: []
+    }
+  },
+  {
+    method: "GET",
+    path: "/mappings",
+    handler: "controller.getLanguageOptions",
+    config: {
+      policies: []
+    }
+  },
+  {
+    method: "POST",
+    path: "/translate",
+    handler: "controller.requestTranslation",
+    config: {
+      policies: []
+    }
+  },
+  {
+    method: "POST",
+    path: "/import",
+    handler: "controller.importData",
+    config: {
+      auth: false,
+      policies: []
+    }
+  },
+  {
+    method: "POST",
+    path: "/export",
+    handler: "controller.exportData",
+    config: {
+      auth: false,
+      policies: []
+    }
+  },
+  {
+    method: "GET",
+    path: "/",
+    handler: "controller.ping",
+    config: {
+      auth: false,
+      policies: []
+    }
+  },
+  {
+    method: "GET",
+    path: "/languages",
+    handler: "controller.getLanguages",
+    config: {
+      auth: false,
+      policies: []
+    }
+  },
+  {
+    method: "GET",
+    path: "/email",
+    handler: "controller.getEmail",
+    config: {
+      policies: []
+    }
+  },
+  {
+    method: "POST",
+    path: "/entrydata",
+    handler: "controller.getEntryData",
+    config: {
+      policies: []
+    }
+  }
+];
+const getContentType = async (contentTypeID) => {
+  const contentType = await strapi.contentType(contentTypeID);
+  if (!contentType?.attributes) {
+    throw new Error(`Content type or schema not found: ${contentTypeID}`);
+  }
+  return contentType;
+};
+const parsePayload = (payload) => {
+  const [contentTypeID, entryID] = payload.element.includes("#") ? payload.element.split("#") : [payload.element, void 0];
+  const locale = payload.source.includes("-") ? payload.source.split("-")[0] : payload.source;
+  return { contentTypeID, entryID, locale };
+};
+const getComponentSchema = async (componentName) => {
+  try {
+    return await strapi.components[componentName];
+  } catch (error) {
+    console.error(`Failed to get component schema for ${componentName}:`, error);
+    return null;
+  }
+};
+const buildPopulateConfig = async (schema) => {
+  const populate = {};
+  for (const [fieldName, attribute] of Object.entries(schema.attributes)) {
+    if (attribute.type === "component") {
+      const componentSchema = await getComponentSchema(attribute.component);
+      if (componentSchema) {
+        const nestedPopulate = await buildPopulateConfig(componentSchema);
+        populate[fieldName] = {
+          populate: Object.keys(nestedPopulate).length ? nestedPopulate : "*"
+        };
+      } else {
+        populate[fieldName] = { populate: "*" };
+      }
+    } else if (attribute.type === "dynamiczone") {
+      populate[fieldName] = { populate: "*" };
+    }
+  }
+  return populate;
+};
+const getEntry = async (contentTypeID, entryID, locale) => {
+  try {
+    const contentType = await strapi.contentTypes[contentTypeID];
+    const populateConfig = await buildPopulateConfig(contentType);
+    const query = {
+      locale,
+      populate: populateConfig
+    };
+    if (entryID) {
+      Object.assign(query, { documentId: entryID });
+    }
+    const entry = await strapi.documents(contentTypeID).findFirst(query);
+    return entry;
+  } catch (error) {
+    console.error("Entry fetch error:", error);
+    return null;
+  }
+};
+const transformResponse = (data) => data.map(
+  (item) => item.realType === "blocks" && Array.isArray(item.translatableValue[0]) ? { ...item, translatableValue: item.translatableValue[0] } : item
+);
+function formatText(child) {
+  if (child.type === "link") {
+    return `<a href="${child.url}">${child.children.map((sub) => sub.text).join("")}</a>`;
+  }
+  let text = child.text || "";
+  if (child.bold) text = `<strong>${text}</strong>`;
+  if (child.italic) text = `<em>${text}</em>`;
+  if (child.underline) text = `<u>${text}</u>`;
+  if (child.strikethrough) text = `<del>${text}</del>`;
+  return text;
+}
+function renderChildren(children) {
+  return children.map(formatText).join("");
+}
+function renderHeading(element) {
+  return `<h${element.level}>${renderChildren(element.children)}</h${element.level}>`;
+}
+function renderParagraph(element) {
+  return `<p>${renderChildren(element.children)}</p>`;
+}
+function renderList(element) {
+  const tag = element.format === "unordered" ? "ul" : "ol";
+  const items = element.children.map(renderListItem).join("");
+  return `<${tag}>${items}</${tag}>`;
+}
+function renderListItem(item) {
+  const content = item.children.map(formatText).join("");
+  return `<li>${content}</li>`;
+}
+function jsonToHtml(jsonData) {
+  return jsonData.map((element) => {
+    switch (element.type) {
+      case "heading":
+        return renderHeading(element);
+      case "paragraph":
+        return renderParagraph(element);
+      case "list":
+        return renderList(element);
+      default:
+        return "";
+    }
+  }).join("");
+}
+const processComponent = async (fieldName, componentName, value, schemaName, componentId) => {
+  const contentFields = [];
+  const componentSchema = await strapi.components[componentName];
+  if (!componentSchema) {
+    throw new Error(`Component schema not found for ${componentName}`);
+  }
+  const schemaAttributes = componentSchema.attributes || {};
+  const dataToProcess = value || {};
+  if (Array.isArray(dataToProcess)) {
+    for (const item of dataToProcess) {
+      const processedFields = await processComponentFields$1(
+        item,
+        schemaAttributes,
+        fieldName,
+        componentName,
+        schemaName,
+        item.id
+      );
+      contentFields.push(...processedFields);
+    }
+  } else {
+    const processedFields = await processComponentFields$1(
+      dataToProcess,
+      schemaAttributes,
+      fieldName,
+      componentName,
+      schemaName,
+      componentId
+    );
+    contentFields.push(...processedFields);
+  }
+  return contentFields;
+};
+const shouldSkipField$1 = (key, fieldSchema) => {
+  return key === "id" || fieldSchema.private;
+};
+const isTranslatableField$1 = (type) => {
+  return ["string", "text", "blocks", "richtext"].includes(type);
+};
+const getTranslatedValue = (type, value) => {
+  if (type === "blocks") {
+    return value ? jsonToHtml(value) : "";
+  }
+  return value.toString();
+};
+const buildTranslatable = (key, fieldSchema, value, parentPath, componentId, schemaName) => {
+  return {
+    field: key,
+    type: ["richtext", "blocks"].includes(fieldSchema.type) ? "html" : "text",
+    translatableValue: [value],
+    realType: fieldSchema.type,
+    componentInfo: {
+      namePath: parentPath,
+      id: componentId,
+      schemaName
+    }
+  };
+};
+const processComponentFields$1 = async (componentData, schema, parentField, componentName, schemaName, componentId) => {
+  const contentFields = [];
+  const parentPath = parentField.split(".");
+  for (const [key, fieldSchema] of Object.entries(schema)) {
+    if (shouldSkipField$1(key, fieldSchema)) continue;
+    const value = componentData?.[key];
+    const fieldPath = `${parentField}.${key}`;
+    if (fieldSchema.type === "component") {
+      if (!fieldSchema.component) continue;
+      const nestedFields = await processComponent(
+        fieldPath,
+        fieldSchema.component,
+        value || {},
+        fieldSchema.component,
+        value?.id
+      );
+      contentFields.push(...nestedFields);
+      continue;
+    }
+    if (!isTranslatableField$1(fieldSchema.type)) continue;
+    if (value === null || value === void 0 || value === "") continue;
+    const translatedValue = getTranslatedValue(fieldSchema.type, value);
+    const translatable = buildTranslatable(
+      key,
+      fieldSchema,
+      translatedValue,
+      parentPath,
+      componentId,
+      schemaName
+    );
+    contentFields.push(translatable);
+  }
+  return contentFields;
+};
+const isFieldLocalizable = (fieldSchema, parentSchema) => {
+  if (fieldSchema.pluginOptions?.i18n?.localized !== void 0) {
+    return fieldSchema.pluginOptions.i18n.localized;
+  }
+  if (parentSchema.pluginOptions?.i18n?.localized === true) {
+    const localizableTypes = ["string", "text", "blocks", "richtext"];
+    return localizableTypes.includes(fieldSchema.type);
+  }
+  return false;
+};
+const DEFAULT_FIELDS = /* @__PURE__ */ new Set([
+  "id",
+  "documentId",
+  "createdAt",
+  "updatedAt",
+  "publishedAt",
+  "locale",
+  "localizations",
+  "updatedBy",
+  "createdBy"
+]);
+const isEmpty = (value) => value === null || value === void 0 || value === "";
+const isTranslatableField = (fieldSchema) => ["string", "text", "blocks", "richtext"].includes(fieldSchema.type) && fieldSchema.pluginOptions?.i18n?.localized !== false;
+const processDynamicZone = async (key, value, schema) => {
+  const results = [];
+  for (const component of value) {
+    const componentName = component?.__component;
+    if (!componentName) continue;
+    const fields = await processComponent(
+      key,
+      componentName,
+      component,
+      componentName,
+      component.id
+    );
+    results.push(...fields);
+  }
+  return results;
+};
+const processComponentField = async (key, value, fieldSchema) => {
+  const results = [];
+  if (fieldSchema.repeatable && Array.isArray(value)) {
+    for (const component of value) {
+      const fields = await processComponent(
+        key,
+        fieldSchema.component,
+        component,
+        fieldSchema.component,
+        component.id
+      );
+      results.push(...fields);
+    }
+  } else {
+    const fields = await processComponent(
+      key,
+      fieldSchema.component,
+      value,
+      fieldSchema.component,
+      value.id
+    );
+    results.push(...fields);
+  }
+  return results;
+};
+const processRegularField = (key, value, fieldSchema) => {
+  const translatedValue = fieldSchema.type === "blocks" ? jsonToHtml(value) : value.toString();
+  return {
+    field: key,
+    type: ["richtext", "blocks"].includes(fieldSchema.type) ? "html" : "text",
+    translatableValue: [translatedValue],
+    realType: fieldSchema.type
+  };
+};
+const processEntryFields = async (entry, schema, locale) => {
+  const contentFields = [];
+  for (const [key, value] of Object.entries(entry)) {
+    if (shouldSkipField(key, value)) continue;
+    const fieldSchema = schema[key];
+    if (!fieldSchema) continue;
+    if (isDynamicZone(fieldSchema, value, schema)) {
+      const zoneFields = await processDynamicZone(key, value);
+      contentFields.push(...zoneFields);
+      continue;
+    }
+    if (isComponent(fieldSchema, value, schema)) {
+      const componentFields = await processComponentField(key, value, fieldSchema);
+      contentFields.push(...componentFields);
+      continue;
+    }
+    if (isTranslatableField(fieldSchema)) {
+      const translatedField = processRegularField(key, value, fieldSchema);
+      contentFields.push(translatedField);
+    }
+  }
+  return contentFields;
+};
+const shouldSkipField = (key, value) => {
+  return DEFAULT_FIELDS.has(key) || isEmpty(value);
+};
+const isDynamicZone = (fieldSchema, value, schema) => {
+  return fieldSchema.type === "dynamiczone" && isFieldLocalizable(fieldSchema, schema) && Array.isArray(value);
+};
+const isComponent = (fieldSchema, value, schema) => {
+  return fieldSchema.type === "component" && isFieldLocalizable(fieldSchema, schema);
+};
+function parseInlineElements(text) {
+  if (!text.includes("<")) {
+    return [{ type: "text", text }];
+  }
+  const linkRegex = /<a\s+href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/g;
+  if (text.includes("<a ")) {
+    let linkMatch;
+    let lastIndex = 0;
+    const elements = [];
+    while ((linkMatch = linkRegex.exec(text)) !== null) {
+      const [fullMatch, url, linkContent] = linkMatch;
+      if (linkMatch.index > lastIndex) {
+        const beforeText = text.substring(lastIndex, linkMatch.index);
+        if (beforeText) {
+          elements.push(...parseInlineElements(beforeText));
+        }
+      }
+      elements.push({
+        type: "link",
+        url,
+        children: parseInlineElements(linkContent)
+      });
+      lastIndex = linkMatch.index + fullMatch.length;
+    }
+    if (lastIndex < text.length) {
+      const afterText = text.substring(lastIndex);
+      if (afterText) {
+        elements.push(...parseInlineElements(afterText));
+      }
+    }
+    return elements;
+  }
+  const formatRegex = /<(strong|em|u|del)>([\s\S]*?)<\/\1>/;
+  const match = formatRegex.exec(text);
+  if (match) {
+    const [fullMatch, tag, content] = match;
+    const beforeText = text.substring(0, match.index);
+    const afterText = text.substring(match.index + fullMatch.length);
+    const elements = [];
+    if (beforeText) {
+      elements.push(...parseInlineElements(beforeText));
+    }
+    const nestedElements = parseInlineElements(content);
+    nestedElements.forEach((element) => {
+      if (tag === "strong") element.bold = true;
+      else if (tag === "em") element.italic = true;
+      else if (tag === "u") element.underline = true;
+      else if (tag === "del") element.strikethrough = true;
+    });
+    elements.push(...nestedElements);
+    if (afterText) {
+      elements.push(...parseInlineElements(afterText));
+    }
+    return elements;
+  }
+  return [{ type: "text", text }];
+}
+function parseHeading(tag, innerText) {
+  const level = parseInt(tag[1]);
+  return {
+    type: "heading",
+    level,
+    children: [{ type: "text", text: innerText.trim() }]
+  };
+}
+function parseParagraph(innerText) {
+  return {
+    type: "paragraph",
+    children: parseInlineElements(innerText)
+  };
+}
+function parseList(tag, innerText) {
+  const listType = tag === "ul" ? "unordered" : "ordered";
+  const listItems = [];
+  const listItemRegex = /<li>(.*?)<\/li>/g;
+  let itemMatch;
+  while ((itemMatch = listItemRegex.exec(innerText)) !== null) {
+    listItems.push({
+      type: "list-item",
+      children: parseInlineElements(itemMatch[1])
+    });
+  }
+  return {
+    type: "list",
+    format: listType,
+    children: listItems
+  };
+}
+function htmlToJson(htmlData) {
+  const jsonData = [];
+  const blockRegex = /<(h[1-3]|p|ul|ol)(?:[^>]*?)>([\s\S]*?)<\/\1>/g;
+  let match;
+  while ((match = blockRegex.exec(htmlData)) !== null) {
+    const [, tag, content] = match;
+    switch (tag) {
+      case "h1":
+      case "h2":
+      case "h3":
+        jsonData.push(parseHeading(tag, content));
+        break;
+      case "p":
+        if (content.includes("<a ")) {
+          const linkRegex = /<a\s+href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/g;
+          let linkMatch;
+          let lastIndex = 0;
+          const children = [];
+          children.push({ type: "text", text: "" });
+          while ((linkMatch = linkRegex.exec(content)) !== null) {
+            const [fullMatch, url, linkText] = linkMatch;
+            if (linkMatch.index > lastIndex) {
+              const beforeLinkText = content.substring(lastIndex, linkMatch.index);
+              if (beforeLinkText) {
+                children.push({ type: "text", text: beforeLinkText });
+              }
+            }
+            children.push({
+              type: "link",
+              url,
+              children: [{ type: "text", text: linkText }]
+            });
+            lastIndex = linkMatch.index + fullMatch.length;
+          }
+          const afterLastLink = content.substring(lastIndex);
+          if (afterLastLink) {
+            children.push({ type: "text", text: afterLastLink });
+          } else {
+            children.push({ type: "text", text: "" });
+          }
+          jsonData.push({
+            type: "paragraph",
+            children
+          });
+        } else {
+          jsonData.push(parseParagraph(content));
+        }
+        break;
+      case "ul":
+      case "ol":
+        jsonData.push(parseList(tag, content));
+        break;
+    }
+  }
+  return jsonData;
+}
+async function updateEntry(contentTypeID, entryID, sourceLocale, targetLocale, data, attributes) {
+  if (!entryID) {
+    const singleTypeData = await strapi.documents(contentTypeID).findFirst();
+    entryID = singleTypeData.documentId;
+  }
+  const originalEntry = await strapi.documents(contentTypeID).findFirst({
+    documentId: entryID,
+    locale: sourceLocale
+  });
+  const processedData = processDataRecursively(data);
+  const localizedData = {};
+  for (const field in processedData) {
+    if (attributes[field] && (!attributes[field].pluginOptions?.i18n || attributes[field].pluginOptions?.i18n?.localized !== false)) {
+      localizedData[field] = processedData[field];
+    }
+  }
+  await strapi.documents(contentTypeID).update({
+    documentId: entryID,
+    locale: targetLocale,
+    data: localizedData
+  });
+  if (originalEntry.publishedAt !== null) {
+    await strapi.documents(contentTypeID).publish({
+      documentId: entryID,
+      locale: sourceLocale
+    });
+  }
+}
+function processDataRecursively(data) {
+  if (!data || typeof data !== "object") {
+    return data;
+  }
+  if (Array.isArray(data)) {
+    return data.map((item) => processDataRecursively(item));
+  }
+  const result = {};
+  for (const key in data) {
+    const value = data[key];
+    if (typeof value === "string" && (key.includes("Blocks") || key.includes("RTBlocks") || key === "blocks")) {
+      result[key] = htmlToJson(value);
+    } else if (value && typeof value === "object") {
+      result[key] = processDataRecursively(value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function organizeFields(fields) {
+  const componentFieldsMap = /* @__PURE__ */ new Map();
+  const dynamicZoneFields = /* @__PURE__ */ new Map();
+  const regularFields = [];
+  fields.forEach((field) => {
+    if (!field.componentInfo) {
+      regularFields.push(field);
+      return;
+    }
+    const { namePath, id } = field.componentInfo;
+    const pathString = namePath.join(".");
+    if (namePath[0] === "dynamiczone") {
+      if (!dynamicZoneFields.has(id)) {
+        dynamicZoneFields.set(id, []);
+      }
+      dynamicZoneFields.get(id)?.push(field);
+    } else {
+      if (!componentFieldsMap.has(pathString)) {
+        componentFieldsMap.set(pathString, []);
+      }
+      componentFieldsMap.get(pathString)?.push(field);
+    }
+  });
+  return { regularFields, componentFieldsMap, dynamicZoneFields };
+}
+function processRegularFields(regularFields, acc) {
+  regularFields.forEach((field) => {
+    acc[field.field] = field.translatableValue[0];
+  });
+  return acc;
+}
+function processRepeatableComponents(fields, existingEntry, rootPath) {
+  const existingComponents = existingEntry?.[rootPath] || [];
+  const componentsById = /* @__PURE__ */ new Map();
+  fields.forEach((field) => {
+    if (!field.componentInfo) {
+      console.warn(`Component info missing for field: ${field.field}`);
+      return;
+    }
+    const componentId = field.componentInfo.id;
+    if (!componentsById.has(componentId)) {
+      const existingComponent = existingComponents.find(
+        (c) => c.id === componentId
+      );
+      componentsById.set(
+        componentId,
+        existingComponent ? { ...existingComponent } : {}
+      );
+    }
+    const component = componentsById.get(componentId);
+    component[field.field] = field.translatableValue[0];
+  });
+  return Array.from(componentsById.values()).map((comp) => {
+    if (!existingComponents.find((ec) => ec.id === comp.id)) {
+      const { id, ...rest } = comp;
+      return rest;
+    }
+    return comp;
+  }).filter((comp) => Object.keys(comp).length > 0);
+}
+function processNestedComponents(fields, pathParts, existingEntry, acc) {
+  let current = acc;
+  let currentExisting = existingEntry;
+  pathParts.forEach((part, index2) => {
+    if (!current[part]) {
+      current[part] = {};
+      if (currentExisting?.[part]?.id) {
+        current[part].id = currentExisting[part].id;
+      }
+    }
+    if (index2 === pathParts.length - 1) {
+      fields.forEach((field) => {
+        current[part][field.field] = field.translatableValue[0];
+      });
+    } else {
+      current = current[part];
+      currentExisting = currentExisting?.[part];
+    }
+  });
+}
+function processComponentFields(componentFieldsMap, acc, existingEntry, targetSchema) {
+  componentFieldsMap.forEach((fields, namePath) => {
+    if (!fields.length) return;
+    const pathParts = namePath.split(".");
+    const rootPath = pathParts[0];
+    const schema = targetSchema.attributes?.[rootPath];
+    if (schema?.repeatable) {
+      acc[rootPath] = processRepeatableComponents(
+        fields,
+        existingEntry,
+        rootPath
+      );
+    } else {
+      processNestedComponents(fields, pathParts, existingEntry, acc);
+    }
+  });
+  return acc;
+}
+function transformFieldsToData(fields) {
+  return fields.reduce((acc, field) => {
+    if (!field.translatableValue) {
+      acc[field.field] = "";
+      return acc;
+    }
+    if (field.realType === "blocks") {
+      acc[field.field] = htmlToJson(field.translatableValue[0] || "");
+    } else if (field.realType === "richtext") {
+      acc[field.field] = field.translatableValue[0] || "";
+    } else {
+      acc[field.field] = Array.isArray(field.translatableValue) && field.translatableValue.length > 1 ? field.translatableValue.join(" ") : field.translatableValue[0] || "";
+    }
+    return acc;
+  }, {});
+}
+function processDynamicZones(dynamicZoneFields, acc, existingEntry) {
+  if (dynamicZoneFields.size > 0) {
+    const existingDynamicZone = existingEntry?.dynamiczone || [];
+    acc.dynamiczone = Array.from(dynamicZoneFields.entries()).sort(([a], [b]) => a - b).map(([_, fields]) => {
+      if (!fields[0].componentInfo) {
+        console.warn(
+          `Component info missing for dynamic zone field: ${fields[0].field}`
+        );
+        return null;
+      }
+      const { schemaName } = fields[0].componentInfo;
+      const componentData = transformFieldsToData(fields);
+      const matchingComponent = existingDynamicZone.find(
+        (comp) => comp.__component === schemaName
+      );
+      return {
+        __component: schemaName,
+        ...componentData,
+        ...matchingComponent?.id ? { id: matchingComponent.id } : {}
+      };
+    }).filter(Boolean);
+  }
+  return acc;
+}
+function prepareImportData(translatables, existingEntry, targetSchema) {
+  return translatables.reduce((acc, doc) => {
+    const { regularFields, componentFieldsMap, dynamicZoneFields } = organizeFields(translatables);
+    const withRegularFields = processRegularFields(regularFields, acc);
+    const withComponentFields = processComponentFields(
+      componentFieldsMap,
+      withRegularFields,
+      existingEntry,
+      targetSchema
+    );
+    const withDynamicZones = processDynamicZones(
+      dynamicZoneFields,
+      withComponentFields,
+      existingEntry
+    );
+    return withDynamicZones;
+  }, {});
+}
+const jwt = require("jsonwebtoken");
+const crypto = require("crypto");
+const service = ({ strapi: strapi2 }) => {
+  const pluginStore = strapi2.store({
+    type: "plugin",
+    name: "translationstudio"
+  });
+  return {
+    // translationstudio Lizenz
+    async getLicense() {
+      const result = await pluginStore.get({ key: "license" });
+      return { license: result };
+    },
+    async setLicense(license) {
+      try {
+        await pluginStore.set({
+          key: "license",
+          value: license
+        });
+        return { success: true };
+      } catch (error) {
+        return { success: false };
+      }
+    },
+    // Access Token
+    async getToken() {
+      try {
+        const result = await pluginStore.get({ key: "token" });
+        return { token: result };
+      } catch (error) {
+        return { token: null };
+      }
+    },
+    async generateToken() {
+      const secretKey = crypto.randomBytes(64).toString("hex");
+      const token = jwt.sign(
+        {
+          app: "translationstudio",
+          iat: Math.floor(Date.now() / 1e3)
+        },
+        secretKey,
+        { expiresIn: "10y" }
+      );
+      await pluginStore.set({
+        key: "token",
+        value: token
+      });
+      return { token };
+    },
+    async getLanguageOptions() {
+      const { license } = await this.getLicense();
+      const response = await fetch(
+        "https://cms-strapi-service-7866fdd79eab.herokuapp.com/mappings",
+        {
+          headers: { Authorization: `${license}` }
+        }
+      );
+      const responseData = await response.json();
+      return responseData;
+    },
+    async exportData(payload) {
+      const { contentTypeID, entryID, locale } = parsePayload(payload);
+      const contentType = await getContentType(contentTypeID);
+      const entry = await getEntry(contentTypeID, entryID, locale);
+      const contentFields = await processEntryFields(
+        entry,
+        contentType.attributes
+      );
+      return transformResponse(contentFields);
+    },
+    async importData(payload) {
+      const { contentTypeID, entryID } = parsePayload(payload);
+      const sourceLocale = payload.source;
+      const targetLocale = payload.target;
+      try {
+        const existingEntry = await getEntry(
+          contentTypeID,
+          entryID,
+          targetLocale
+        );
+        const targetSchema = await getContentType(contentTypeID);
+        const data = prepareImportData(
+          payload.document[0].fields,
+          existingEntry,
+          targetSchema
+        );
+        if (targetSchema.pluginOptions.i18n.localized === true) {
+          await updateEntry(
+            contentTypeID,
+            entryID,
+            sourceLocale,
+            targetLocale,
+            data,
+            targetSchema.attributes
+          );
+        }
+        return { success: true };
+      } catch (error) {
+        return { success: false };
+      }
+    },
+    async requestTranslation(payload) {
+      const { license } = await this.getLicense();
+      const response = await fetch(
+        "https://cms-strapi-service-7866fdd79eab.herokuapp.com/translate",
+        {
+          method: "POST",
+          headers: {
+            Authorization: `${license}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(payload)
+        }
+      );
+      if (response.status === 204) return true;
+    },
+    async getEmail(ctx) {
+      const user = ctx.state.user;
+      if (!user) {
+        return { email: null };
+      }
+      return { email: user.email };
+    },
+    async getLanguages() {
+      try {
+        const locales = await strapi2.plugin("i18n").service("locales").find();
+        const localeMap = {};
+        locales.forEach((locale) => {
+          localeMap[locale.code] = locale.name;
+        });
+        return localeMap;
+      } catch (error) {
+        return {};
+      }
+    },
+    async ping() {
+      return;
+    },
+    async getEntryData(contentTypeID, entryID, locale) {
+      const entry = await getEntry(contentTypeID, entryID, locale);
+      return entry;
+    }
+  };
+};
+const services = {
+  service
+};
+const index = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes,
+  policies,
+  middlewares
+};
+module.exports = index;