@translationstudio/translationstudio-strapi-extension 1.1.0 → 1.1.1

package/dist/server/index.mjs

@@ -288,49 +288,54 @@ const getEntry = async (contentTypeID, entryID, locale) => {
 const transformResponse = (data) => data.map(
   (item) => item.realType === "blocks" && Array.isArray(item.translatableValue[0]) ? { ...item, translatableValue: item.translatableValue[0] } : item
 );
+function jsonToHtml(json) {
+  if (!json || !Array.isArray(json)) {
+    return "";
+  }
+  return json.map((node) => processNode(node)).join("");
+}
+function processNode(node) {
+  if (!node) return "";
+  switch (node.type) {
+    case "paragraph":
+      return `<p>${node.children.map(processNode).join("")}</p>`;
+    case "heading":
+      const level = node.level || 1;
+      return `<h${level}>${node.children.map(processNode).join("")}</h${level}>`;
+    case "link":
+      const url = node.url || "#";
+      return `<a href="${url}">${node.children.map(processNode).join("")}</a>`;
+    case "list":
+      const listType = node.format === "ordered" ? "ol" : "ul";
+      return `<${listType}>${node.children.map(processNode).join("")}</${listType}>`;
+    case "list-item":
+      return `<li>${node.children.map(processNode).join("")}</li>`;
+    case "quote":
+      return `<blockquote>${node.children.map(processNode).join("")}</blockquote>`;
+    case "code":
+      return `<pre><code>${node.children.map((child) => child.text).join("")}</code></pre>`;
+    case "image":
+      return `<img src="${node.url}" alt="${node.alt || ""}" />`;
+    case "text":
+      return formatText(node);
+    default:
+      return node.children && Array.isArray(node.children) ? node.children.map(processNode).join("") : node.text || "";
+  }
+}
 function formatText(child) {
   if (child.type === "link") {
-    return `<a href="${child.url}">${child.children.map((sub) => sub.text).join("")}</a>`;
+    return `<a href="${child.url}">${child.children.map((sub) => formatText(sub)).join("")}</a>`;
   }
   let text = child.text || "";
+  if (child.code) text = `<code>${text}</code>`;
   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>`;
+  if (child.strikethrough) {
+    text = `~~${text}~~`;
+  }
   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];
@@ -528,149 +533,197 @@ const isDynamicZone = (fieldSchema, value, schema) => {
 const isComponent = (fieldSchema, value, schema) => {
   return fieldSchema.type === "component" && isFieldLocalizable(fieldSchema, schema);
 };
-function parseInlineElements(text) {
-  if (!text.includes("<")) {
-    return [{ type: "text", text }];
+function htmlToJson(html) {
+  function parseHTML(html2) {
+    const elements2 = [];
+    const tagRegex = /<([a-z0-9]+)((?:\s+[a-z-]+="[^"]*")*)\s*>([\s\S]*?)<\/\1>/gi;
+    let match;
+    while ((match = tagRegex.exec(html2)) !== null) {
+      const [, tag, attributes, content] = match;
+      const attrs = {};
+      const attrRegex = /([a-z-]+)="([^"]*)"/gi;
+      let attrMatch;
+      while ((attrMatch = attrRegex.exec(attributes)) !== null) {
+        attrs[attrMatch[1]] = attrMatch[2];
+      }
+      elements2.push({ tag, attrs, content });
+    }
+    return elements2;
   }
-  const linkRegex = /<a\s+href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/g;
-  if (text.includes("<a ")) {
-    let linkMatch;
+  function parseInlineContent(content) {
+    const segments = [];
+    let currentText = "";
+    let formatStack = [];
+    let currentFormat = {
+      bold: false,
+      italic: false,
+      underline: false,
+      code: false,
+      strikethrough: false
+    };
+    const pushSegment = () => {
+      if (currentText) {
+        segments.push({
+          type: "text",
+          text: currentText,
+          ...Object.fromEntries(Object.entries(currentFormat).filter(([_, value]) => value))
+        });
+        currentText = "";
+      }
+    };
+    const tags = content.split(/(<[^>]+>|~~)/);
+    for (const tag of tags) {
+      if (!tag) continue;
+      if (tag === "~~") {
+        pushSegment();
+        currentFormat.strikethrough = !currentFormat.strikethrough;
+        continue;
+      }
+      if (tag.startsWith("<")) {
+        pushSegment();
+        if (tag.startsWith("</")) {
+          const tagName = tag.slice(2, -1).toLowerCase();
+          const lastTag = formatStack.pop();
+          if (lastTag && lastTag.type === tagName) {
+            switch (tagName) {
+              case "strong":
+                currentFormat.bold = false;
+                break;
+              case "em":
+                currentFormat.italic = false;
+                break;
+              case "u":
+                currentFormat.underline = false;
+                break;
+              case "code":
+                currentFormat.code = false;
+                break;
+              case "del":
+                currentFormat.strikethrough = false;
+                break;
+            }
+          }
+        } else {
+          const tagName = tag.slice(1, -1).toLowerCase();
+          formatStack.push({ type: tagName, index: segments.length });
+          switch (tagName) {
+            case "strong":
+              currentFormat.bold = true;
+              break;
+            case "em":
+              currentFormat.italic = true;
+              break;
+            case "u":
+              currentFormat.underline = true;
+              break;
+            case "code":
+              currentFormat.code = true;
+              break;
+            case "del":
+              currentFormat.strikethrough = true;
+              break;
+          }
+        }
+      } else {
+        currentText += tag;
+      }
+    }
+    pushSegment();
+    return segments.filter((segment) => segment.text.length > 0);
+  }
+  function parseList(html2, format) {
+    const listItems = html2.match(/<li>([\s\S]*?)<\/li>/g) || [];
+    return {
+      type: "list",
+      format,
+      children: listItems.map((item) => ({
+        type: "list-item",
+        children: parseListContent(item.replace(/<li>|<\/li>/g, ""))
+      }))
+    };
+  }
+  function parseListContent(content) {
+    const children = [];
+    const linkRegex = /<a\s+href="([^"]+)">([\s\S]*?)<\/a>/g;
     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));
+    let match;
+    while ((match = linkRegex.exec(content)) !== null) {
+      const [fullMatch, href, linkText] = match;
+      if (match.index > lastIndex) {
+        const textBefore = content.slice(lastIndex, match.index);
+        if (textBefore.trim()) {
+          children.push(...parseInlineContent(textBefore));
         }
       }
-      elements.push({
+      children.push({
         type: "link",
-        url,
-        children: parseInlineElements(linkContent)
+        url: href,
+        children: parseInlineContent(linkText)
       });
-      lastIndex = linkMatch.index + fullMatch.length;
+      lastIndex = match.index + fullMatch.length;
     }
-    if (lastIndex < text.length) {
-      const afterText = text.substring(lastIndex);
-      if (afterText) {
-        elements.push(...parseInlineElements(afterText));
+    if (lastIndex < content.length) {
+      const remainingText = content.slice(lastIndex);
+      if (remainingText.trim()) {
+        children.push(...parseInlineContent(remainingText));
       }
     }
-    return elements;
+    return children;
   }
-  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;
+  function parseParagraph(content) {
+    return {
+      type: "paragraph",
+      children: parseListContent(content)
+    };
   }
-  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])
-    });
+  const blocks = [];
+  const elements = parseHTML(html);
+  if (elements.length === 0 && html.trim()) {
+    blocks.push(parseParagraph(html));
+    return blocks;
   }
-  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) {
+  for (const element of elements) {
+    switch (element.tag.toLowerCase()) {
       case "h1":
       case "h2":
       case "h3":
-        jsonData.push(parseHeading(tag, content));
+      case "h4":
+      case "h5":
+      case "h6":
+        blocks.push({
+          type: "heading",
+          level: parseInt(element.tag.slice(1)),
+          children: parseListContent(element.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));
-        }
+        blocks.push(parseParagraph(element.content));
         break;
       case "ul":
+        blocks.push(parseList(element.content, "unordered"));
+        break;
       case "ol":
-        jsonData.push(parseList(tag, content));
+        blocks.push(parseList(element.content, "ordered"));
         break;
+      case "blockquote":
+        blocks.push({
+          type: "quote",
+          children: [parseParagraph(element.content)]
+        });
+        break;
+      case "pre":
+        if (element.content.includes("<code>")) {
+          blocks.push({
+            type: "code",
+            children: parseInlineContent(element.content)
+          });
+        }
+        break;
+      default:
+        blocks.push(parseParagraph(element.content));
     }
   }
-  return jsonData;
+  return blocks;
 }
 async function updateEntry(contentTypeID, entryID, sourceLocale, targetLocale, data, attributes) {
   if (!entryID) {
@@ -682,6 +735,14 @@ async function updateEntry(contentTypeID, entryID, sourceLocale, targetLocale, d
     locale: sourceLocale
   });
   const processedData = processDataRecursively(data);
+  for (const [key, value] of Object.entries(processedData)) {
+    if (attributes[key]?.type === "blocks" && typeof value === "string") {
+      console.warn(
+        `Field ${key} is a blocks field but received string value. Converting to blocks format.`
+      );
+      processedData[key] = htmlToJson(value);
+    }
+  }
   const localizedData = {};
   for (const field in processedData) {
     if (attributes[field] && (!attributes[field].pluginOptions?.i18n || attributes[field].pluginOptions?.i18n?.localized !== false)) {
@@ -700,23 +761,29 @@ async function updateEntry(contentTypeID, entryID, sourceLocale, targetLocale, d
     });
   }
 }
-function processDataRecursively(data) {
+function processDataRecursively(data, schema) {
   if (!data || typeof data !== "object") {
     return data;
   }
   if (Array.isArray(data)) {
+    if (data[0]?.fields) {
+      const processedFields = {};
+      for (const fieldData of data[0].fields) {
+        if (fieldData.realType === "blocks") {
+          if (fieldData.translatableValue?.[0]) {
+            processedFields[fieldData.field] = htmlToJson(fieldData.translatableValue[0]);
+          }
+        } else {
+          processedFields[fieldData.field] = fieldData.translatableValue?.[0] || null;
+        }
+      }
+      return processedFields;
+    }
     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;
-    }
+    result[key] = processDataRecursively(data[key]);
   }
   return result;
 }
@@ -761,16 +828,15 @@ function processRepeatableComponents(fields, existingEntry, rootPath) {
     }
     const componentId = field.componentInfo.id;
     if (!componentsById.has(componentId)) {
-      const existingComponent = existingComponents.find(
-        (c) => c.id === componentId
-      );
-      componentsById.set(
-        componentId,
-        existingComponent ? { ...existingComponent } : {}
-      );
+      const existingComponent = existingComponents.find((c) => c.id === componentId);
+      componentsById.set(componentId, existingComponent ? { ...existingComponent } : {});
     }
     const component = componentsById.get(componentId);
-    component[field.field] = field.translatableValue[0];
+    if (field.realType === "blocks") {
+      component[field.field] = htmlToJson(field.translatableValue[0] || "");
+    } else {
+      component[field.field] = field.translatableValue[0];
+    }
   });
   return Array.from(componentsById.values()).map((comp) => {
     if (!existingComponents.find((ec) => ec.id === comp.id)) {
@@ -792,7 +858,11 @@ function processNestedComponents(fields, pathParts, existingEntry, acc) {
     }
     if (index2 === pathParts.length - 1) {
       fields.forEach((field) => {
-        current[part][field.field] = field.translatableValue[0];
+        if (field.realType === "blocks") {
+          current[part][field.field] = htmlToJson(field.translatableValue[0] || "");
+        } else {
+          current[part][field.field] = field.translatableValue[0];
+        }
       });
     } else {
       current = current[part];
@@ -807,11 +877,7 @@ function processComponentFields(componentFieldsMap, acc, existingEntry, targetSc
     const rootPath = pathParts[0];
     const schema = targetSchema.attributes?.[rootPath];
     if (schema?.repeatable) {
-      acc[rootPath] = processRepeatableComponents(
-        fields,
-        existingEntry,
-        rootPath
-      );
+      acc[rootPath] = processRepeatableComponents(fields, existingEntry, rootPath);
     } else {
       processNestedComponents(fields, pathParts, existingEntry, acc);
     }
@@ -929,12 +995,9 @@ const service = ({ strapi: strapi2 }) => {
     },
     async getLanguageOptions() {
       const { license } = await this.getLicense();
-      const response = await fetch(
-        TRANSLATIONTUDIO_URL + "/mappings",
-        {
-          headers: { Authorization: `${license}` }
-        }
-      );
+      const response = await fetch(TRANSLATIONTUDIO_URL + "/mappings", {
+        headers: { Authorization: `${license}` }
+      });
       const responseData = await response.json();
       return responseData;
     },
@@ -942,10 +1005,7 @@ const service = ({ strapi: strapi2 }) => {
       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
-      );
+      const contentFields = await processEntryFields(entry, contentType.attributes);
       return transformResponse(contentFields);
     },
     async importData(payload) {
@@ -953,17 +1013,9 @@ const service = ({ strapi: strapi2 }) => {
       const sourceLocale = payload.source;
       const targetLocale = payload.target;
       try {
-        const existingEntry = await getEntry(
-          contentTypeID,
-          entryID,
-          targetLocale
-        );
+        const existingEntry = await getEntry(contentTypeID, entryID, targetLocale);
         const targetSchema = await getContentType(contentTypeID);
-        const data = prepareImportData(
-          payload.document[0].fields,
-          existingEntry,
-          targetSchema
-        );
+        const data = prepareImportData(payload.document[0].fields, existingEntry, targetSchema);
         if (targetSchema.pluginOptions.i18n.localized === true) {
           await updateEntry(
             contentTypeID,
@@ -981,17 +1033,14 @@ const service = ({ strapi: strapi2 }) => {
     },
     async requestTranslation(payload) {
       const { license } = await this.getLicense();
-      const response = await fetch(
-        TRANSLATIONTUDIO_URL + "/translate",
-        {
-          method: "POST",
-          headers: {
-            Authorization: `${license}`,
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify(payload)
-        }
-      );
+      const response = await fetch(TRANSLATIONTUDIO_URL + "/translate", {
+        method: "POST",
+        headers: {
+          Authorization: `${license}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(payload)
+      });
       if (response.status === 204) return true;
     },
     async getEmail(ctx) {

package/dist/server/src/services/functions/exportData/jsonToHtml.d.ts

@@ -1,2 +1,6 @@
-declare function jsonToHtml(jsonData: any): string;
-export default jsonToHtml;
+/**
+ * Converts a richtext JSON structure to HTML
+ * @param {any} json - The JSON representation of richtext content
+ * @returns {string} - The converted HTML string
+ */
+export default function jsonToHtml(json: any): string;

package/dist/server/src/services/functions/importData/htmlToJson.d.ts

@@ -1,2 +1 @@
-declare function htmlToJson(htmlData: string): any[];
-export default htmlToJson;
+export default function htmlToJson(html: string): any[];

package/dist/server/src/services/functions/importData/parseInlineElements.d.ts

@@ -1,2 +1,22 @@
-declare function parseInlineElements(text: string): any[];
+/**
+ * Parses HTML and markdown-formatted text into a structured format for richtext fields
+ * @param {string} text - The HTML/markdown text to parse
+ * @returns {ContentNode[]} - Array of structured text elements
+ */
+interface TextNode {
+    type: 'text';
+    text: string;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    code?: boolean;
+    strikethrough?: boolean;
+}
+interface LinkNode {
+    type: 'link';
+    url: string;
+    children: TextNode[];
+}
+type ContentNode = TextNode | LinkNode;
+declare function parseInlineElements(text: string): ContentNode[];
 export default parseInlineElements;

package/dist/server/src/services/functions/importData/processComponentFields.d.ts

@@ -1,2 +1,2 @@
-import { TranslationstudioTranslatable } from "../../../../../Types";
+import { TranslationstudioTranslatable } from '../../../../../Types';
 export declare function processComponentFields(componentFieldsMap: Map<string, TranslationstudioTranslatable[]>, acc: Record<string, any>, existingEntry: any, targetSchema: any): Record<string, any>;

package/dist/server/src/services/functions/importData/updateEntry.d.ts

@@ -1,2 +1,2 @@
 export declare function updateEntry(contentTypeID: string, entryID: string, sourceLocale: string, targetLocale: string, data: Record<string, any>, attributes: Record<string, any>): Promise<void>;
-export declare function processDataRecursively(data: any): any;
+export declare function processDataRecursively(data: any, schema?: any): any;

package/dist/server/src/services/service.d.ts

@@ -1,5 +1,5 @@
-import type { Core } from "@strapi/strapi";
-import type { ExportPayload, ImportPayload, LocaleMap, TranslationRequest } from "../../../Types";
+import type { Core } from '@strapi/strapi';
+import type { ExportPayload, ImportPayload, LocaleMap, TranslationRequest } from '../../../Types';
 declare const service: ({ strapi }: {
     strapi: Core.Strapi;
 }) => {

package/package.json

@@ -4,7 +4,7 @@
   "license": "GPL-2.0-only",
   "author": "Duncan Leininger <duncan.leininger@idmedia.com>",
   "homepage": "https://translationstudio.tech",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "keywords": [
     "translationstudio",
     "strapi",