@justanarthur/payload-plugin-translator 1.3.21 → 3.1.0

package/dist/shared/chunk-p03jz82h.js

@@ -0,0 +1,623 @@
+import {
+  samePlaceholders,
+  traverseFields,
+  collectTranslatableFields,
+  entityKey,
+  sourceHash
+} from "./chunk-9d433kmv.js";
+import {
+  TRANSLATION_STATUS_SLUG2
+} from "./chunk-31qgv1zk.js";
+
+// src/translate/operation.ts
+import he from "he";
+import { APIError as APIError3 } from "payload";
+
+// src/translate/findEntityWithConfig.ts
+import { APIError } from "payload";
+var findConfigBySlug = (slug, enities) => enities.find((entity) => entity.slug === slug);
+var findEntityWithConfig = async (args) => {
+  const { collectionSlug, globalSlug, id, locale, overrideAccess, req } = args;
+  if (!collectionSlug && !globalSlug)
+    throw new APIError("Bad Request", 400);
+  const { payload } = req;
+  const { config } = payload;
+  const isGlobal = !!globalSlug;
+  if (!isGlobal && !id)
+    throw new APIError("Bad Request", 400);
+  const entityConfig = isGlobal ? findConfigBySlug(globalSlug, config.globals) : findConfigBySlug(collectionSlug, config.collections);
+  if (!entityConfig)
+    throw new APIError("Bad Request", 400);
+  const docPromise = isGlobal ? payload.findGlobal({
+    depth: 0,
+    fallbackLocale: false,
+    locale,
+    overrideAccess,
+    req,
+    slug: args.globalSlug
+  }) : payload.findByID({
+    collection: collectionSlug,
+    depth: 0,
+    fallbackLocale: false,
+    id,
+    locale,
+    overrideAccess,
+    req
+  });
+  const doc = await docPromise;
+  return {
+    config: entityConfig,
+    doc
+  };
+};
+
+// src/translate/updateEntity.ts
+import { APIError as APIError2 } from "payload";
+var updateEntity = ({
+  collectionSlug,
+  data,
+  depth: incomingDepth,
+  globalSlug,
+  id,
+  locale,
+  overrideAccess,
+  req
+}) => {
+  if (!collectionSlug && !globalSlug)
+    throw new APIError2("Bad Request", 400);
+  const isGlobal = !!globalSlug;
+  if (!isGlobal && !id)
+    throw new APIError2("Bad Request", 400);
+  const depth = incomingDepth ?? req.payload.config.defaultDepth;
+  const promise = isGlobal ? req.payload.updateGlobal({
+    data,
+    depth,
+    context: { disableAutoTranslate: true },
+    locale,
+    overrideAccess,
+    req,
+    slug: globalSlug
+  }) : req.payload.update({
+    collection: collectionSlug,
+    context: { disableAutoTranslate: true },
+    data,
+    depth,
+    id,
+    locale,
+    overrideAccess,
+    req
+  });
+  return promise;
+};
+
+// src/translate/operation.ts
+var preview = (value) => {
+  const flat = (typeof value === "string" ? value : String(value ?? "")).replace(/\s+/g, " ").trim();
+  return JSON.stringify(flat.length > 60 ? `${flat.slice(0, 57)}…` : flat);
+};
+var translateOperation2 = async (args) => {
+  const req = "req" in args ? args.req : {
+    payload: args.payload
+  };
+  const { collectionSlug, globalSlug, id, locale, localeFrom, overrideAccess } = args;
+  const { config, doc: dataFrom } = await findEntityWithConfig({
+    collectionSlug,
+    globalSlug,
+    id,
+    locale: localeFrom,
+    overrideAccess,
+    req
+  });
+  const resolver = (req.payload.config.custom?.translator?.resolvers ?? []).find((each) => each.key === args.resolver);
+  if (!resolver)
+    throw new APIError3(`Resolver with the key ${args.resolver} was not found`);
+  const valuesToTranslate = [];
+  let translatedData = args.data;
+  if (!translatedData) {
+    const { doc } = await findEntityWithConfig({
+      collectionSlug,
+      globalSlug,
+      id,
+      locale,
+      overrideAccess,
+      req
+    });
+    translatedData = doc;
+  }
+  traverseFields({
+    dataFrom,
+    emptyOnly: args.emptyOnly,
+    fields: config.fields,
+    translatedData,
+    valuesToTranslate,
+    _options: req.payload.config.custom?.translator?._options
+  });
+  const entityLabel = `${collectionSlug || globalSlug}#${id ?? ""}`;
+  const direction = `${args.localeFrom}→${args.locale}`;
+  req.payload.logger.info({
+    msg: `[translate] ${entityLabel} ${direction}: traversed ${valuesToTranslate.length} translatable value(s)`
+  });
+  const resolveResult = valuesToTranslate.length === 0 ? { success: true, translatedTexts: [] } : await resolver.resolve({
+    localeFrom: args.localeFrom,
+    localeTo: args.locale,
+    req,
+    texts: valuesToTranslate.map((each) => each.value)
+  });
+  let result;
+  if (!resolveResult.success) {
+    req.payload.logger.warn({
+      msg: `[translate] ${entityLabel} ${direction}: resolver failed — ${valuesToTranslate.length} value(s) traversed but NOT translated` + (valuesToTranslate.length ? `
+${valuesToTranslate.map((v) => `  ${v.path ?? "(unknown)"}: ${preview(v.value)}`).join(`
+`)}` : "")
+    });
+    result = {
+      success: false
+    };
+  } else if (resolveResult.translatedTexts.length !== valuesToTranslate.length) {
+    req.payload.logger.error({
+      msg: `[translate] ${entityLabel} ${direction}: resolver returned ${resolveResult.translatedTexts.length} value(s) for ${valuesToTranslate.length} — nothing applied`
+    });
+    result = {
+      success: false
+    };
+  } else {
+    const summary = [];
+    resolveResult.translatedTexts.forEach((translated, index) => {
+      const entry = valuesToTranslate[index];
+      const formattedValue = typeof entry.value === "string" && /&[#\w]+;/.test(entry.value) ? translated : he.decode(translated);
+      if (typeof entry.value === "string" && !samePlaceholders(entry.value, formattedValue)) {
+        summary.push(`  ${entry.path ?? "(unknown)"}: placeholders changed, kept source ${preview(entry.value)}`);
+        entry.onTranslate(entry.value);
+        return;
+      }
+      summary.push(`  ${entry.path ?? "(unknown)"}: ${preview(entry.value)} → ${preview(formattedValue)}`);
+      entry.onTranslate(formattedValue);
+    });
+    req.payload.logger.info({
+      msg: `[translate] ${entityLabel} ${direction}: translated ${resolveResult.translatedTexts.length} value(s)` + (summary.length ? `
+${summary.join(`
+`)}` : "")
+    });
+    if (args.update) {
+      const { _locale, _parent_id, createdAt, updatedAt, ...data } = translatedData;
+      await updateEntity({
+        collectionSlug,
+        data,
+        depth: 0,
+        globalSlug,
+        id,
+        locale,
+        overrideAccess,
+        req
+      });
+    }
+    result = {
+      success: true,
+      translatedData,
+      dataFrom
+    };
+  }
+  return result;
+};
+
+// src/jobs/constants.ts
+var TRANSLATE_TASK_SLUG2 = "translateEntityToLocale";
+var TRANSLATE_WORKFLOW_SLUG2 = "translateEntityToLocales";
+
+// src/jobs/createAutoTranslateCollectionHook.ts
+function createAutoTranslateCollectionHook2(options) {
+  const {
+    collectionSlug,
+    defaultLocale: defaultLocaleOption,
+    targetLocales: targetLocalesOption,
+    onlyOnPublished = true,
+    workflowSlug = TRANSLATE_WORKFLOW_SLUG2
+  } = options;
+  const afterChange = async ({ doc, req }) => {
+    if (shouldSkipAutoTranslate(req.context))
+      return doc;
+    const typed = doc;
+    const requestLocale = readRequestLocale(req);
+    const defaultLocale = defaultLocaleOption ?? readConfigDefaultLocale(req) ?? "";
+    if (!requestLocale || !defaultLocale || requestLocale !== defaultLocale)
+      return doc;
+    if (!req.user)
+      return doc;
+    if (onlyOnPublished && typed._status && typed._status !== "published")
+      return doc;
+    const targetLocales = targetLocalesOption ?? readTargetLocales(req, defaultLocale);
+    if (targetLocales.length === 0)
+      return doc;
+    const resolverKey = options.resolverKey ?? readFirstResolverKey(req);
+    if (!resolverKey) {
+      req.payload.logger.error({
+        msg: `auto-translate: no resolver key available for collection ${collectionSlug} — pass \`resolverKey\` to \`createAutoTranslateCollectionHook\` or configure \`translator.resolvers\` in \`translator({...})\``
+      });
+      return doc;
+    }
+    const updatedAt = typed.updatedAt ?? new Date().toISOString();
+    const toLocales = targetLocales.filter((toLocale) => toLocale !== defaultLocale);
+    if (toLocales.length === 0)
+      return doc;
+    try {
+      const job = await req.payload.jobs.queue({
+        req,
+        workflow: workflowSlug,
+        input: {
+          id: typed.id,
+          updatedAt,
+          collection: collectionSlug,
+          fromLocale: defaultLocale,
+          resolver: resolverKey || undefined,
+          toLocales
+        }
+      });
+      req.payload.logger.info({
+        msg: `auto-translate: queued translation of ${collectionSlug}#${typed.id} → [${toLocales.join(", ")}] (job ${job.id})`
+      });
+    } catch (error) {
+      req.payload.logger.error({
+        msg: `auto-translate: failed to queue ${collectionSlug}#${typed.id}: ${String(error)}`
+      });
+    }
+    return doc;
+  };
+  return { afterChange };
+}
+function shouldSkipAutoTranslate(context) {
+  return Boolean(context?.disableAutoTranslate);
+}
+function readRequestLocale(req) {
+  if (!req || typeof req !== "object")
+    return "";
+  const locale = req.locale;
+  return typeof locale === "string" && locale.length > 0 ? locale : "";
+}
+function readConfigDefaultLocale(req) {
+  if (!req || typeof req !== "object")
+    return "";
+  const config = req.payload?.config;
+  const def = config?.localization?.defaultLocale;
+  return typeof def === "string" && def.length > 0 ? def : "";
+}
+function readTargetLocales(req, defaultLocale) {
+  if (!req || typeof req !== "object")
+    return [];
+  const list = req.payload?.config?.localization?.locales;
+  if (!Array.isArray(list) || list.length === 0)
+    return [];
+  const out = [];
+  for (const entry of list) {
+    const code = typeof entry === "string" ? entry : entry?.code;
+    if (typeof code === "string" && code.length > 0 && code !== defaultLocale) {
+      out.push(code);
+    }
+  }
+  return out;
+}
+function readFirstResolverKey(req) {
+  if (!req || typeof req !== "object")
+    return "";
+  const custom = req.payload?.config?.custom?.translator?.resolvers;
+  if (!Array.isArray(custom) || custom.length === 0)
+    return "";
+  const first = custom[0];
+  return typeof first?.key === "string" ? first.key : "";
+}
+
+// src/jobs/createAutoTranslateGlobalHook.ts
+function createAutoTranslateGlobalHook2(options) {
+  const {
+    globalSlug,
+    defaultLocale: defaultLocaleOption,
+    targetLocales: targetLocalesOption,
+    workflowSlug = TRANSLATE_WORKFLOW_SLUG2
+  } = options;
+  return async ({ doc, req }) => {
+    if (shouldSkipAutoTranslate2(req.context))
+      return doc;
+    const typed = doc;
+    const requestLocale = readRequestLocale2(req);
+    const defaultLocale = defaultLocaleOption ?? readConfigDefaultLocale2(req) ?? "";
+    if (!requestLocale || !defaultLocale || requestLocale !== defaultLocale)
+      return doc;
+    if (!req.user)
+      return doc;
+    if (typed._status && typed._status !== "published")
+      return doc;
+    const targetLocales = targetLocalesOption ?? readTargetLocales2(req, defaultLocale);
+    if (targetLocales.length === 0)
+      return doc;
+    const resolverKey = options.resolverKey ?? readFirstResolverKey2(req);
+    if (!resolverKey) {
+      req.payload.logger.error({
+        msg: `auto-translate: no resolver key available for global ${globalSlug} — pass \`resolverKey\` to \`createAutoTranslateGlobalHook\` or configure \`translator.resolvers\` in \`translator({...})\``
+      });
+      return doc;
+    }
+    const updatedAt = typed.updatedAt ?? new Date().toISOString();
+    const toLocales = targetLocales.filter((toLocale) => toLocale !== defaultLocale);
+    if (toLocales.length === 0)
+      return doc;
+    try {
+      const job = await req.payload.jobs.queue({
+        req,
+        workflow: workflowSlug,
+        input: {
+          updatedAt,
+          global: globalSlug,
+          fromLocale: defaultLocale,
+          resolver: resolverKey || undefined,
+          toLocales
+        }
+      });
+      req.payload.logger.info({
+        msg: `auto-translate: queued translation of ${globalSlug} → [${toLocales.join(", ")}] (job ${job.id})`
+      });
+    } catch (error) {
+      req.payload.logger.error({
+        msg: `auto-translate: failed to queue ${globalSlug}: ${String(error)}`
+      });
+    }
+    return doc;
+  };
+}
+function shouldSkipAutoTranslate2(context) {
+  return Boolean(context?.disableAutoTranslate);
+}
+function readRequestLocale2(req) {
+  if (!req || typeof req !== "object")
+    return "";
+  const locale = req.locale;
+  return typeof locale === "string" && locale.length > 0 ? locale : "";
+}
+function readConfigDefaultLocale2(req) {
+  if (!req || typeof req !== "object")
+    return "";
+  const config = req.payload?.config;
+  const def = config?.localization?.defaultLocale;
+  return typeof def === "string" && def.length > 0 ? def : "";
+}
+function readTargetLocales2(req, defaultLocale) {
+  if (!req || typeof req !== "object")
+    return [];
+  const list = req.payload?.config?.localization?.locales;
+  if (!Array.isArray(list) || list.length === 0)
+    return [];
+  const out = [];
+  for (const entry of list) {
+    const code = typeof entry === "string" ? entry : entry?.code;
+    if (typeof code === "string" && code.length > 0 && code !== defaultLocale) {
+      out.push(code);
+    }
+  }
+  return out;
+}
+function readFirstResolverKey2(req) {
+  if (!req || typeof req !== "object")
+    return "";
+  const custom = req.payload?.config?.custom?.translator?.resolvers;
+  if (!Array.isArray(custom) || custom.length === 0)
+    return "";
+  const first = custom[0];
+  return typeof first?.key === "string" ? first.key : "";
+}
+
+// src/review/recordTranslationStatus.ts
+var upsertTranslationStatus = async (req, entity, locale, data) => {
+  if (!req.payload.collections[TRANSLATION_STATUS_SLUG2])
+    return;
+  const existing = await req.payload.find({
+    collection: TRANSLATION_STATUS_SLUG2,
+    where: { and: [{ entity: { equals: entity } }, { locale: { equals: locale } }] },
+    limit: 1,
+    depth: 0,
+    overrideAccess: true,
+    req
+  });
+  const row = existing.docs[0];
+  if (row)
+    await req.payload.update({ collection: TRANSLATION_STATUS_SLUG2, id: row.id, data, overrideAccess: true, req });
+  else
+    await req.payload.create({ collection: TRANSLATION_STATUS_SLUG2, data: { entity, locale, ...data }, overrideAccess: true, req });
+};
+var recordTranslationStatus = async ({ req, collectionSlug, globalSlug, id, locale, config, dataFrom, reviewedBy }) => {
+  const hash = sourceHash(collectTranslatableFields({
+    config,
+    dataFrom,
+    dataTarget: {},
+    options: req.payload.config.custom?.translator?._options
+  }));
+  const now = new Date().toISOString();
+  await upsertTranslationStatus(req, entityKey({ collectionSlug, globalSlug, id }), locale, reviewedBy ? { reviewedHash: hash, reviewedAt: now, reviewedBy } : { sourceHash: hash, translatedAt: now });
+};
+
+// src/jobs/createTranslateTask.ts
+function createTranslateTask2(options = {}) {
+  const { slug = "translateEntityToLocale" } = options;
+  return {
+    slug,
+    inputSchema: [
+      { name: "id", type: "number", required: false },
+      { name: "collection", type: "text", required: false },
+      { name: "global", type: "text", required: false },
+      { name: "fromLocale", type: "text", required: true },
+      { name: "toLocale", type: "text", required: true },
+      { name: "resolver", type: "text", required: false },
+      { name: "mode", type: "text", required: false }
+    ],
+    outputSchema: [],
+    retries: 3,
+    handler: async (args) => {
+      const { input, job, req } = args;
+      const { id, collection, global, fromLocale, toLocale, resolver: inputResolver } = input;
+      const mode = input.mode ?? readAutoTranslateMode(req);
+      if (!collection && !global) {
+        throw new Error("translateTask: either `collection` or `global` must be provided");
+      }
+      const resolverKey = options.resolverKey ?? inputResolver ?? readFirstResolverKey3(req);
+      if (!resolverKey) {
+        throw new Error(`translateTask: no resolver key available — pass \`resolverKey\` to \`createTranslateTask\` or queue the workflow with a \`resolver\` input. Did you forget to pass \`translator.resolvers\` to \`translator({...})\`?`);
+      }
+      const entityLabel = collection || global;
+      req.payload.logger.info({
+        jobId: job.id,
+        msg: `translating ${entityLabel} to locale ${toLocale}`
+      });
+      let result;
+      try {
+        result = await translateOperation2({
+          req,
+          collectionSlug: collection,
+          globalSlug: global,
+          emptyOnly: mode !== "all",
+          id,
+          locale: toLocale,
+          localeFrom: fromLocale,
+          overrideAccess: true,
+          resolver: resolverKey,
+          update: false
+        });
+      } catch (error) {
+        req.payload.logger.error({
+          jobId: job.id,
+          msg: `translateOperation threw for ${entityLabel} → ${toLocale}: ${String(error)}`
+        });
+        throw error;
+      }
+      if (!result.success) {
+        req.payload.logger.error({
+          jobId: job.id,
+          msg: `translation for ${entityLabel} to ${toLocale} failed (resolver returned success=false)`
+        });
+        throw new Error(`translateTask: resolver returned success=false for ${entityLabel} → ${toLocale}`);
+      }
+      const latest = await findEntityWithConfig({
+        collectionSlug: collection,
+        globalSlug: global,
+        id,
+        locale: fromLocale,
+        overrideAccess: true,
+        req
+      });
+      if (String(latest.doc?.updatedAt) !== String(result.dataFrom?.updatedAt)) {
+        req.payload.logger.warn({
+          jobId: job.id,
+          msg: `[translate] ${entityLabel}#${id ?? global} changed during translation — skipping ${toLocale}, the newer save re-queues it`
+        });
+        return { output: { success: true } };
+      }
+      const translated = result.translatedData ?? {};
+      const { _locale: _dropLocale, _parent_id: _dropParent, updatedAt: _dropUpdatedAt, createdAt: _dropCreatedAt, ...data } = translated;
+      req.payload.logger.info({
+        jobId: job.id,
+        msg: `[translate] persisting ${entityLabel}#${id ?? global} → ${toLocale}`
+      });
+      try {
+        await updateEntity({
+          collectionSlug: collection,
+          data,
+          depth: 0,
+          globalSlug: global,
+          id,
+          locale: toLocale,
+          overrideAccess: true,
+          req
+        });
+        await recordTranslationStatus({
+          req,
+          collectionSlug: collection,
+          globalSlug: global,
+          id,
+          locale: toLocale,
+          config: latest.config,
+          dataFrom: latest.doc
+        });
+      } catch (error) {
+        req.payload.logger.error({
+          jobId: job.id,
+          msg: `persist failed for ${entityLabel} (id=${id ?? global}) at locale ${toLocale}: ${String(error)}`
+        });
+        throw error;
+      }
+      req.payload.logger.info({
+        jobId: job.id,
+        msg: `translation complete for ${entityLabel} → ${toLocale}`
+      });
+      return { output: { success: true } };
+    }
+  };
+}
+function readFirstResolverKey3(req) {
+  if (!req || typeof req !== "object")
+    return "";
+  const custom = req.payload?.config?.custom?.translator?.resolvers;
+  if (!Array.isArray(custom) || custom.length === 0)
+    return "";
+  const first = custom[0];
+  return typeof first?.key === "string" ? first.key : "";
+}
+function readAutoTranslateMode(req) {
+  return req.payload.config.custom?.translator?.autoTranslateMode === "all" ? "all" : "missing";
+}
+
+// src/jobs/createTranslateWorkflow.ts
+function createTranslateWorkflow2(options = {}) {
+  const { slug = "translateEntityToLocales", taskSlug = "translateEntityToLocale" } = options;
+  return {
+    slug,
+    inputSchema: [
+      { name: "id", type: "number", required: false },
+      { name: "updatedAt", type: "date", required: true },
+      { name: "collection", type: "text", required: false },
+      { name: "global", type: "text", required: false },
+      { name: "fromLocale", type: "text", required: true },
+      { name: "toLocales", type: "json", required: false },
+      { name: "toLocale", type: "text", required: false },
+      { name: "resolver", type: "text", required: false }
+    ],
+    handler: async (args) => {
+      const { job, req, tasks } = args;
+      const { id, collection, global, fromLocale, toLocales, toLocale, updatedAt, resolver } = job.input;
+      if (!collection && !global) {
+        throw new Error("translateWorkflow: either `collection` or `global` must be provided");
+      }
+      if (typeof req.payload.config.localization !== "object") {
+        req.payload.logger.error({
+          jobId: job.id,
+          msg: "localization is not enabled — skipping auto-translation workflow"
+        });
+        return;
+      }
+      const entityKey = collection ? `${collection}-${id}` : global;
+      const updatedAtIso = updatedAt instanceof Date ? updatedAt.toISOString() : String(updatedAt);
+      const requested = Array.isArray(toLocales) && toLocales.length > 0 ? toLocales : toLocale ? [toLocale] : [];
+      const targets = requested.filter((locale) => typeof locale === "string" && locale && locale !== fromLocale);
+      if (targets.length === 0) {
+        req.payload.logger.warn({
+          jobId: job.id,
+          msg: `translateWorkflow: no target locales for ${entityKey} — nothing to translate`
+        });
+        return;
+      }
+      req.payload.logger.info({
+        jobId: job.id,
+        msg: `scheduling translation of ${entityKey}: ${fromLocale} → [${targets.join(", ")}]`
+      });
+      for (const target of targets) {
+        await tasks[taskSlug](`${entityKey}-${fromLocale}-${target}-${updatedAtIso}`, {
+          input: {
+            id,
+            collection,
+            global,
+            fromLocale,
+            toLocale: target,
+            resolver
+          }
+        });
+      }
+    }
+  };
+}
+
+export { findEntityWithConfig, translateOperation2, TRANSLATE_TASK_SLUG2, TRANSLATE_WORKFLOW_SLUG2, createAutoTranslateCollectionHook2, createAutoTranslateGlobalHook2, recordTranslationStatus, createTranslateTask2, createTranslateWorkflow2 };

package/dist/shared/chunk-zenq7s47.js

@@ -0,0 +1,15 @@
+// src/resolvers/copy.ts
+var copyResolver2 = () => {
+  return {
+    key: "copy",
+    resolve: (args) => {
+      const { texts } = args;
+      return {
+        success: true,
+        translatedTexts: texts
+      };
+    }
+  };
+};
+
+export { copyResolver2 };

package/dist/shared/chunk-zs19h344.js

@@ -0,0 +1,55 @@
+import {
+  chunkArray
+} from "./chunk-e6c0qzkt.js";
+
+// src/resolvers/google.ts
+var localeToCountryCodeMapper = {
+  ua: "uk"
+};
+var mapLocale = (incoming) => (incoming in localeToCountryCodeMapper) ? localeToCountryCodeMapper[incoming] : incoming;
+var googleResolver2 = ({
+  apiKey,
+  chunkLength = 100
+}) => {
+  return {
+    key: "google",
+    resolve: async (args) => {
+      const { localeFrom, localeTo, req, texts } = args;
+      const apiUrl = `https://translation.googleapis.com/language/translate/v2?key=${apiKey}`;
+      const responses = await Promise.all(chunkArray(texts, chunkLength).map((q) => fetch(apiUrl, {
+        body: JSON.stringify({
+          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({
+            googleResponse: data,
+            message: "An error occurred when trying to translate the data using Google API"
+          });
+        return {
+          data,
+          success: res.ok
+        };
+      })));
+      if (responses.some((res) => !res.success)) {
+        return {
+          success: false
+        };
+      }
+      const translatedTexts = responses.flatMap((chunk) => chunk.data.data.translations).map((translation) => translation.translatedText);
+      return {
+        success: true,
+        translatedTexts
+      };
+    }
+  };
+};
+
+export { googleResolver2 };