@justanarthur/payload-plugin-translator 1.3.21 → 3.1.0

package/dist/shared/chunk-15n5q7wd.js

@@ -0,0 +1,253 @@
+import {
+  samePlaceholders,
+  isOpaqueText,
+  collectTranslatableFields,
+  entityKey,
+  sourceHash
+} from "./chunk-9d433kmv.js";
+import {
+  TRANSLATION_STATUS_SLUG2
+} from "./chunk-31qgv1zk.js";
+
+// src/review/plainText.ts
+var plainText = (value) => {
+  if (typeof value === "string")
+    return value;
+  if (!value || typeof value !== "object")
+    return "";
+  if (Array.isArray(value))
+    return value.map(plainText).filter(Boolean).join(" ");
+  const node = value;
+  if (typeof node.text === "string")
+    return node.text;
+  if ("root" in node)
+    return plainText(node.root);
+  if (Array.isArray(node.children))
+    return node.children.map(plainText).filter(Boolean).join(node.type === "root" ? `
+` : "");
+  return "";
+};
+
+// src/review/computeStatus.ts
+var normalize = (text) => text.replace(/\s+/g, " ").trim();
+var classify = (field, sourceText, targetText) => {
+  if (!normalize(targetText))
+    return "missing";
+  if (field.type === "json" && !samePlaceholders(sourceText, targetText))
+    return "placeholders";
+  const same = normalize(sourceText) === normalize(targetText);
+  if (same && field.type !== "slug" && normalize(sourceText).length > 3 && !isOpaqueText(sourceText) && /\s/.test(normalize(sourceText)))
+    return "identical";
+  return "ok";
+};
+var computeStatus = (fields) => {
+  const statuses = [];
+  for (const field of fields) {
+    const sourceText = plainText(field.source);
+    if (!normalize(sourceText))
+      continue;
+    const targetText = plainText(field.target);
+    statuses.push({ ...field, sourceText, targetText, state: classify(field, sourceText, targetText) });
+  }
+  const count = (state) => statuses.filter((each) => each.state === state).length;
+  const ok = count("ok");
+  return {
+    fields: statuses,
+    summary: {
+      total: statuses.length,
+      ok,
+      missing: count("missing"),
+      identical: count("identical"),
+      placeholders: count("placeholders"),
+      coverage: statuses.length ? Math.floor(ok / statuses.length * 100) : 100,
+      slugMissing: statuses.some((each) => each.type === "slug" && each.state === "missing")
+    }
+  };
+};
+
+// src/review/loadReview.ts
+var readLocales = (req) => {
+  const localization = req.payload.config.localization;
+  if (!localization)
+    return { defaultLocale: "", targetLocales: [] };
+  const codes = localization.locales.map((each) => typeof each === "string" ? each : each.code);
+  return { defaultLocale: localization.defaultLocale, targetLocales: codes.filter((code) => code !== localization.defaultLocale) };
+};
+var pluginOptions = (req) => req.payload.config.custom?.translator;
+var loadStatusRows = async (req, keys) => {
+  if (!keys.length || !req.payload.collections[TRANSLATION_STATUS_SLUG2])
+    return [];
+  const { docs } = await req.payload.find({
+    collection: TRANSLATION_STATUS_SLUG2,
+    where: { entity: { in: keys } },
+    pagination: false,
+    depth: 0,
+    overrideAccess: false,
+    req
+  });
+  return docs;
+};
+var reviewLocale = (config, source, target, hash, row, req) => {
+  const { fields, summary } = computeStatus(collectTranslatableFields({
+    config,
+    dataFrom: source,
+    dataTarget: target ?? {},
+    options: pluginOptions(req)?._options
+  }));
+  return {
+    fields,
+    summary,
+    stale: Boolean(row?.sourceHash) && row?.sourceHash !== hash,
+    reviewed: Boolean(row?.reviewedHash) && row?.reviewedHash === hash
+  };
+};
+var labelOf = (config, doc) => {
+  const title = doc[config.admin?.useAsTitle ?? "id"];
+  return typeof title === "string" && title.trim() ? title : `#${doc.id}`;
+};
+var globalLabel = (config) => typeof config.label === "string" ? config.label : config.slug;
+var hashOf = (config, source, req) => sourceHash(collectTranslatableFields({ config, dataFrom: source, dataTarget: {}, options: pluginOptions(req)?._options }));
+var loadCollectionReview = async ({ req, collectionSlug, page = 1, limit = 25 }) => {
+  const config = req.payload.collections[collectionSlug]?.config;
+  if (!config)
+    throw new Error(`unknown collection ${collectionSlug}`);
+  const { defaultLocale, targetLocales } = readLocales(req);
+  const sources = await req.payload.find({
+    collection: collectionSlug,
+    locale: defaultLocale,
+    fallbackLocale: false,
+    depth: 0,
+    limit,
+    page,
+    sort: "-updatedAt",
+    overrideAccess: false,
+    req
+  });
+  const ids = sources.docs.map((doc) => doc.id);
+  const targets = {};
+  for (const locale of targetLocales) {
+    const { docs } = ids.length ? await req.payload.find({
+      collection: collectionSlug,
+      locale,
+      fallbackLocale: false,
+      depth: 0,
+      where: { id: { in: ids } },
+      pagination: false,
+      overrideAccess: false,
+      req
+    }) : { docs: [] };
+    targets[locale] = new Map(docs.map((doc) => [String(doc.id), doc]));
+  }
+  const keys = ids.map((id) => entityKey({ collectionSlug, id }));
+  const rows = await loadStatusRows(req, keys);
+  const entities = sources.docs.map((doc) => {
+    const source = doc;
+    const key = entityKey({ collectionSlug, id: source.id });
+    const hash = hashOf(config, source, req);
+    return {
+      key,
+      label: labelOf(config, source),
+      collectionSlug,
+      id: source.id,
+      locales: Object.fromEntries(targetLocales.map((locale) => {
+        const { fields: _fields, ...review } = reviewLocale(config, source, targets[locale].get(String(source.id)), hash, rows.find((row) => row.entity === key && row.locale === locale), req);
+        return [locale, review];
+      }))
+    };
+  });
+  return {
+    entities,
+    locales: targetLocales,
+    page: sources.page ?? page,
+    totalPages: sources.totalPages,
+    totalDocs: sources.totalDocs
+  };
+};
+var loadGlobalsReview = async ({ req, globalSlugs }) => {
+  const { defaultLocale, targetLocales } = readLocales(req);
+  const rows = await loadStatusRows(req, globalSlugs.map((globalSlug) => entityKey({ globalSlug })));
+  const entities = [];
+  for (const globalSlug of globalSlugs) {
+    const config = req.payload.config.globals.find((each) => each.slug === globalSlug);
+    if (!config)
+      continue;
+    const read = (locale) => req.payload.findGlobal({
+      slug: globalSlug,
+      locale,
+      fallbackLocale: false,
+      depth: 0,
+      overrideAccess: false,
+      req
+    });
+    const source = await read(defaultLocale);
+    const hash = hashOf(config, source, req);
+    const key = entityKey({ globalSlug });
+    const locales = {};
+    for (const locale of targetLocales) {
+      const { fields: _fields, ...review } = reviewLocale(config, source, await read(locale), hash, rows.find((row) => row.entity === key && row.locale === locale), req);
+      locales[locale] = review;
+    }
+    entities.push({ key, label: globalLabel(config), globalSlug, locales });
+  }
+  return { entities, locales: targetLocales };
+};
+var parseEntityKey = (key) => {
+  const [scope, ...rest] = key.split(":");
+  const value = rest.join(":");
+  return scope === "global" ? { globalSlug: value } : { collectionSlug: scope, id: value };
+};
+var loadEntityLocaleReview = async ({ req, entity, locale }) => {
+  const { defaultLocale } = readLocales(req);
+  const { collectionSlug, globalSlug, id } = parseEntityKey(entity);
+  const config = globalSlug ? req.payload.config.globals.find((each) => each.slug === globalSlug) : req.payload.collections[collectionSlug]?.config;
+  if (!config)
+    throw new Error(`unknown entity ${entity}`);
+  const read = (readLocale) => globalSlug ? req.payload.findGlobal({ slug: globalSlug, locale: readLocale, fallbackLocale: false, depth: 0, overrideAccess: false, req }) : req.payload.findByID({ collection: collectionSlug, id, locale: readLocale, fallbackLocale: false, depth: 0, overrideAccess: false, req });
+  const source = await read(defaultLocale);
+  const target = await read(locale);
+  const rows = await loadStatusRows(req, [entity]);
+  const row = rows.find((each) => each.locale === locale);
+  const review = reviewLocale(config, source, target, hashOf(config, source, req), row, req);
+  return {
+    ...review,
+    entity,
+    locale,
+    defaultLocale,
+    collectionSlug,
+    globalSlug,
+    id,
+    label: globalSlug ? globalLabel(config) : labelOf(config, source),
+    translatedAt: row?.translatedAt,
+    reviewedAt: row?.reviewedAt,
+    reviewedBy: row?.reviewedBy,
+    lastJob: await loadLastJob(req, { collectionSlug, globalSlug, id }, locale)
+  };
+};
+var loadLastJob = async (req, { collectionSlug, globalSlug, id }, locale) => {
+  if (!req.payload.collections["payload-jobs"])
+    return null;
+  try {
+    const { docs } = await req.payload.find({
+      collection: "payload-jobs",
+      sort: "-createdAt",
+      limit: 100,
+      depth: 0,
+      overrideAccess: true,
+      req
+    });
+    const job = docs.find(({ input }) => input && (globalSlug ? input.global === globalSlug : input.collection === collectionSlug && String(input.id) === String(id)) && (!Array.isArray(input.toLocales) || input.toLocales.includes(locale)));
+    if (!job)
+      return null;
+    return {
+      id: job.id,
+      createdAt: job.createdAt,
+      completedAt: job.completedAt,
+      processing: Boolean(job.processing),
+      error: job.hasError ? typeof job.error === "string" ? job.error : JSON.stringify(job.error) : undefined
+    };
+  } catch {
+    return null;
+  }
+};
+
+export { readLocales, loadCollectionReview, loadGlobalsReview, parseEntityKey, loadEntityLocaleReview };

package/dist/shared/chunk-31qgv1zk.js

@@ -0,0 +1,5 @@
+// src/review/constants.ts
+var TRANSLATION_STATUS_SLUG2 = "translation-status";
+var REVIEW_VIEW_PATH = "/translations";
+
+export { TRANSLATION_STATUS_SLUG2, REVIEW_VIEW_PATH };

package/dist/shared/chunk-9d433kmv.js

@@ -0,0 +1,359 @@
+// src/utils/placeholders.ts
+var placeholdersOf = (value) => (value.match(/\{\s*[\w.]+\s*(?:,[^{}]*)?\}/g) ?? []).map((each) => each.replace(/\s+/g, "")).sort();
+var samePlaceholders = (source, translated) => placeholdersOf(source).join("|") === placeholdersOf(translated).join("|");
+
+// src/translate/traverseFields.ts
+import ObjectID from "bson-objectid";
+import { tabHasName } from "payload/shared";
+
+// src/utils/isEmpty.ts
+var isEmpty = (value) => {
+  if (Array.isArray(value))
+    return value.length === 0;
+  if (value === null || typeof value === "undefined")
+    return true;
+  if (typeof value === "object" && Object.keys(value).length === 0)
+    return true;
+  return false;
+};
+
+// src/utils/hasText.ts
+var hasText = (value) => {
+  if (typeof value === "string")
+    return value.trim().length > 0;
+  if (isEmpty(value))
+    return false;
+  if (Array.isArray(value))
+    return value.some(hasText);
+  if (typeof value === "object") {
+    const node = value;
+    if (typeof node.text === "string" && node.text.trim())
+      return true;
+    if ("root" in node)
+      return hasText(node.root);
+    if (Array.isArray(node.children))
+      return node.children.some(hasText);
+    if (node.type === "block" || node.type === "inlineBlock" || node.type === "upload")
+      return true;
+    return !("children" in node) && Object.values(node).some(hasText);
+  }
+  return value !== null && value !== undefined;
+};
+
+// src/utils/isOpaqueText.ts
+var isOpaqueText = (value) => {
+  const text = value.trim();
+  return /^([a-z][a-z0-9+.-]*:|\/\/|\/|#|www\.)/i.test(text) || /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(text) || !/\p{L}/u.test(text);
+};
+
+// src/utils/sanitizeSlug.ts
+var sanitizeSlug = (text) => text.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9-_]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+
+// src/translate/traverseRichText.ts
+var traverseRichText = ({
+  onText,
+  root,
+  siblingData,
+  additionalTraverseRichText
+}) => {
+  siblingData = siblingData ?? root;
+  if (typeof siblingData.text === "string" && siblingData.text.trim()) {
+    onText(siblingData);
+  }
+  if (!("text" in siblingData)) {
+    additionalTraverseRichText?.({ onText, root, siblingData });
+  }
+  if (Array.isArray(siblingData.children)) {
+    for (const child of siblingData.children) {
+      if (child && typeof child === "object")
+        traverseRichText({
+          onText,
+          root,
+          siblingData: child,
+          additionalTraverseRichText
+        });
+    }
+  }
+};
+
+// src/translate/traverseFields.ts
+var joinPath = (base, segment) => base ? `${base}.${segment}` : segment;
+var buildLocalizedRows = (from, existing, isBlocks, emptyOnly) => {
+  const sameShape = existing.length === from.length && (!isBlocks || existing.every((row, index) => row.blockType === from[index].blockType));
+  if (emptyOnly && sameShape)
+    return existing;
+  return from.map((row, index) => {
+    const previous = existing[index] && (!isBlocks || existing[index].blockType === row.blockType) ? existing[index] : undefined;
+    return {
+      ...previous ?? {},
+      id: previous?.id ?? ObjectID().toHexString(),
+      ...isBlocks ? { blockType: row.blockType, blockName: row.blockName ?? previous?.blockName } : {}
+    };
+  });
+};
+var traverseFields = (args) => {
+  const {
+    dataFrom,
+    emptyOnly,
+    fields,
+    localizedParent,
+    path,
+    translatedData,
+    valuesToTranslate,
+    onField,
+    _options
+  } = args;
+  const { additionalTraverseRichText } = _options ?? {};
+  const siblingDataFrom = args.siblingDataFrom ?? dataFrom;
+  const siblingDataTranslated = args.siblingDataTranslated ?? translatedData;
+  const recurse = (overrides) => traverseFields({ ...args, siblingDataFrom, siblingDataTranslated, ...overrides });
+  for (const field of fields) {
+    switch (field.type) {
+      case "tabs":
+        for (const tab of field.tabs) {
+          const hasName = tabHasName(tab);
+          const tabDataFrom = hasName ? siblingDataFrom[tab.name] : siblingDataFrom;
+          if (!tabDataFrom)
+            continue;
+          let tabDataTranslated;
+          if (hasName) {
+            if (!siblingDataTranslated[tab.name])
+              siblingDataTranslated[tab.name] = {};
+            tabDataTranslated = siblingDataTranslated[tab.name];
+          } else {
+            tabDataTranslated = siblingDataTranslated;
+          }
+          recurse({
+            fields: tab.fields,
+            localizedParent: localizedParent || "localized" in tab && Boolean(tab.localized),
+            path: hasName ? joinPath(path, tab.name) : path,
+            siblingDataFrom: tabDataFrom,
+            siblingDataTranslated: tabDataTranslated
+          });
+        }
+        break;
+      case "group": {
+        if (!("name" in field) || !field.name) {
+          recurse({ fields: field.fields });
+          break;
+        }
+        const groupDataFrom = siblingDataFrom[field.name];
+        if (!groupDataFrom)
+          break;
+        if (!siblingDataTranslated[field.name])
+          siblingDataTranslated[field.name] = {};
+        recurse({
+          fields: field.fields,
+          localizedParent: localizedParent || Boolean(field.localized),
+          path: joinPath(path, field.name),
+          siblingDataFrom: groupDataFrom,
+          siblingDataTranslated: siblingDataTranslated[field.name]
+        });
+        break;
+      }
+      case "array":
+      case "blocks": {
+        const isBlocks = field.type === "blocks";
+        const rowsFrom = siblingDataFrom[field.name];
+        if (isEmpty(rowsFrom) || !Array.isArray(rowsFrom))
+          break;
+        const existing = Array.isArray(siblingDataTranslated[field.name]) ? siblingDataTranslated[field.name] : [];
+        const localized = Boolean(field.localized || localizedParent);
+        const rows = localized ? buildLocalizedRows(rowsFrom, existing, isBlocks, emptyOnly) : existing.length ? existing : structuredClone(rowsFrom);
+        rows.forEach((row, index) => {
+          const rowFrom = rowsFrom[index];
+          if (!rowFrom)
+            return;
+          if (!isBlocks) {
+            recurse({
+              fields: field.fields,
+              localizedParent: localized,
+              path: `${joinPath(path, field.name)}[${index}]`,
+              siblingDataFrom: rowFrom,
+              siblingDataTranslated: row
+            });
+            return;
+          }
+          const block = field.blocks.find((each) => each.slug === row.blockType);
+          if (!block)
+            return;
+          recurse({
+            fields: block.fields,
+            localizedParent: localized,
+            path: `${joinPath(path, field.name)}[${index}](${row.blockType})`,
+            siblingDataFrom: rowFrom,
+            siblingDataTranslated: row
+          });
+        });
+        siblingDataTranslated[field.name] = rows;
+        break;
+      }
+      case "collapsible":
+      case "row":
+        recurse({ fields: field.fields });
+        break;
+      case "date":
+      case "checkbox":
+      case "code":
+      case "email":
+      case "number":
+      case "point":
+      case "radio":
+      case "relationship":
+      case "select":
+      case "upload":
+        siblingDataTranslated[field.name] = siblingDataFrom[field.name];
+        break;
+      case "json": {
+        if (!(field.localized || localizedParent))
+          break;
+        const jsonDataFrom = siblingDataFrom[field.name];
+        if (isEmpty(jsonDataFrom))
+          break;
+        const jsonPath = joinPath(path, field.name);
+        const current = siblingDataTranslated[field.name];
+        const currentIsObject = Boolean(current) && typeof current === "object";
+        const jsonDataTranslated = emptyOnly && currentIsObject ? structuredClone(current) : structuredClone(jsonDataFrom);
+        siblingDataTranslated[field.name] = jsonDataTranslated;
+        const traverseObject = (source, target, target0, objPath) => {
+          if (!source || typeof source !== "object")
+            return;
+          for (const key of Object.keys(source)) {
+            const value = source[key];
+            const previous = target0 && typeof target0 === "object" ? target0[key] : undefined;
+            const keyPath = joinPath(objPath, key);
+            if (typeof value === "string") {
+              onField?.({ path: keyPath, type: "json", source: value, target: previous });
+              if (!value.trim())
+                continue;
+              if (emptyOnly && typeof previous === "string" && previous.trim())
+                continue;
+              target[key] = value;
+              if (isOpaqueText(value))
+                continue;
+              valuesToTranslate.push({
+                onTranslate: (translated) => {
+                  target[key] = translated;
+                },
+                value,
+                path: keyPath
+              });
+            } else if (value && typeof value === "object") {
+              if (!target[key] || typeof target[key] !== "object")
+                target[key] = Array.isArray(value) ? [] : {};
+              traverseObject(value, target[key], previous, keyPath);
+            } else if (!(key in target)) {
+              target[key] = value;
+            }
+          }
+        };
+        traverseObject(jsonDataFrom, jsonDataTranslated, currentIsObject ? current : undefined, jsonPath);
+        break;
+      }
+      case "text":
+      case "textarea": {
+        if (field.custom && typeof field.custom === "object" && field.custom.translatorSkip)
+          break;
+        if (!(field.localized || localizedParent))
+          break;
+        if (field.name === "blockName" || field.name === "id")
+          break;
+        const value = siblingDataFrom[field.name];
+        const current = siblingDataTranslated[field.name];
+        const fieldPath = joinPath(path, field.name);
+        const isSlug = field.name === "slug";
+        onField?.({ path: fieldPath, type: isSlug ? "slug" : "text", source: value, target: current });
+        if (typeof value !== "string" || !value.trim())
+          break;
+        const hasCurrent = typeof current === "string" && current.trim().length > 0;
+        if (hasCurrent && (emptyOnly || isSlug))
+          break;
+        if (isOpaqueText(value)) {
+          siblingDataTranslated[field.name] = value;
+          break;
+        }
+        if (isSlug) {
+          const segments = value.split("_");
+          segments.forEach((segment, index) => {
+            valuesToTranslate.push({
+              onTranslate: (translated) => {
+                segments[index] = sanitizeSlug(translated) || segment;
+                siblingDataTranslated[field.name] = segments.join("_");
+              },
+              value: segment.replace(/-/g, " "),
+              path: `${fieldPath}#${index}`
+            });
+          });
+          break;
+        }
+        valuesToTranslate.push({
+          onTranslate: (translated) => {
+            siblingDataTranslated[field.name] = translated;
+          },
+          value,
+          path: fieldPath
+        });
+        break;
+      }
+      case "richText": {
+        if (!(field.localized || localizedParent))
+          break;
+        const richTextDataFrom = siblingDataFrom[field.name];
+        const current = siblingDataTranslated[field.name];
+        const richTextPath = joinPath(path, field.name);
+        onField?.({ path: richTextPath, type: "richText", source: richTextDataFrom, target: current });
+        if (!richTextDataFrom || !hasText(richTextDataFrom))
+          break;
+        if (emptyOnly && hasText(current))
+          break;
+        const isSlate = Array.isArray(richTextDataFrom);
+        const isLexical = typeof richTextDataFrom === "object" && "root" in richTextDataFrom;
+        if (!isSlate && !isLexical)
+          break;
+        const richTextTranslated = structuredClone(richTextDataFrom);
+        siblingDataTranslated[field.name] = richTextTranslated;
+        let richTextNodeIndex = 0;
+        const onText = (siblingData, attribute = "text") => {
+          valuesToTranslate.push({
+            onTranslate: (translated) => {
+              siblingData[attribute] = translated;
+            },
+            value: siblingData[attribute],
+            path: `${richTextPath}#${richTextNodeIndex++}`
+          });
+        };
+        const roots = isLexical ? [richTextTranslated.root] : richTextTranslated;
+        for (const root of roots) {
+          if (root && typeof root === "object")
+            traverseRichText({ onText, root, additionalTraverseRichText });
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+};
+
+// src/review/collectTranslatableFields.ts
+var collectTranslatableFields = ({ config, dataFrom, dataTarget, options }) => {
+  const fields = [];
+  traverseFields({
+    dataFrom,
+    fields: config.fields,
+    translatedData: structuredClone(dataTarget ?? {}),
+    valuesToTranslate: [],
+    onField: (field) => fields.push(field),
+    _options: options
+  });
+  return fields;
+};
+
+// src/review/entityKey.ts
+var entityKey = ({ collectionSlug, globalSlug, id }) => globalSlug ? `global:${globalSlug}` : `${collectionSlug}:${id}`;
+
+// src/review/sourceHash.ts
+import { createHash } from "node:crypto";
+var sourceHash = (fields) => createHash("sha1").update(JSON.stringify(fields.map(({ path, source }) => [path, source]))).digest("hex");
+
+export { samePlaceholders, isOpaqueText, traverseFields, collectTranslatableFields, entityKey, sourceHash };

package/dist/shared/chunk-e6c0qzkt.js

@@ -0,0 +1,6 @@
+// src/utils/chunkArray.ts
+var chunkArray = (array, length) => {
+  return Array.from({ length: Math.ceil(array.length / length) }, (_, i) => array.slice(i * length, i * length + length));
+};
+
+export { chunkArray };

package/dist/shared/chunk-mvqymw6n.js

@@ -0,0 +1,57 @@
+import {
+  chunkArray
+} from "./chunk-e6c0qzkt.js";
+
+// src/resolvers/libreTranslate.ts
+var localeToCountryCodeMapper = {
+  ua: "uk"
+};
+var mapLocale = (incoming) => (incoming in localeToCountryCodeMapper) ? localeToCountryCodeMapper[incoming] : incoming;
+var libreResolver2 = ({
+  apiKey,
+  chunkLength = 100,
+  url = "https://libretranslate.com/translate"
+}) => {
+  return {
+    key: "libre",
+    resolve: async (args) => {
+      const { localeFrom, localeTo, req, texts } = args;
+      const apiUrl = url;
+      const responses = await Promise.all(chunkArray(texts, chunkLength).map((q) => fetch(apiUrl, {
+        body: JSON.stringify({
+          api_key: apiKey,
+          q,
+          source: mapLocale(localeFrom),
+          target: mapLocale(localeTo)
+        }),
+        headers: {
+          "Content-Type": "application/json"
+        },
+        method: "POST"
+      }).then(async (res) => {
+        const data = await res.json();
+        if (!res.ok)
+          req.payload.logger.info({
+            libreResponse: data,
+            message: "An error occurred when trying to translate the data using LibreTranslate API"
+          });
+        return {
+          data,
+          success: res.ok
+        };
+      })));
+      if (responses.some((res) => !res.success)) {
+        return {
+          success: false
+        };
+      }
+      const translatedTexts = responses.flatMap((chunk) => chunk.data.translatedText);
+      return {
+        success: true,
+        translatedTexts
+      };
+    }
+  };
+};
+
+export { libreResolver2 };