@diplodoc/cli 4.13.7 → 4.13.8

package/build/index.js

@@ -3812,9 +3812,6 @@ function normalizeInput(params, language, exts) {
 function resolveSchemas(_path) {
   return null;
 }
-function flat(parts) {
-  return [].concat(...parts);
-}
 var Defer = class {
   constructor() {
     this.promise = new Promise((resolve20, reject) => {
@@ -3841,8 +3838,7 @@ function builder3(argv) {
   }).option("output", {
     alias: "o",
     describe: "output folder where translated markdown will be stored",
-    type: "string",
-    default: process.cwd()
+    type: "string"
   }).option("source", {
     alias: ["sll", "source-language-locale"],
     describe: "source language and locale",
@@ -3924,8 +3920,7 @@ function builder4(argv) {
   }).option("output", {
     alias: "o",
     describe: "output folder where translated markdown will be stored",
-    type: "string",
-    default: process.cwd()
+    type: "string"
   }).option("use-source", {
     describe: "for debug",
     type: "boolean"
@@ -3980,45 +3975,39 @@ function pipeline3(input, output, { useSource }) {
 }
 
 // src/cmd/translate/handler.ts
+var import_axios = __toESM(require("axios"));
 var import_assert3 = require("assert");
 var import_path34 = require("path");
 var import_promises6 = require("fs/promises");
 
 // src/cmd/translate/yandex/auth.ts
 var import_fs14 = require("fs");
+var resolveKey = (data) => {
+  switch (true) {
+    case data.startsWith("y0_"):
+      return "Bearer " + data;
+    case data.startsWith("t1."):
+      return "Bearer " + data;
+    case data.startsWith("AQVN"):
+      return "Api-Key " + data;
+    default:
+      return null;
+  }
+};
 function getYandexAuth(path) {
-  if (path.startsWith("y0_")) {
-    return {
-      oauthToken: path
-    };
+  let auth = resolveKey(path);
+  if (auth !== null) {
+    return auth;
   }
-  const data = (0, import_fs14.readFileSync)(path, "utf8");
-  try {
-    const json = JSON.parse(data);
-    if (isServeseAccount(json)) {
-      return {
-        serviceAccountJson: {
-          serviceAccountId: json.service_account_id,
-          accessKeyId: json.id,
-          privateKey: json.private_key
-        }
-      };
-    }
-  } catch (e) {
+  auth = resolveKey((0, import_fs14.readFileSync)(path, "utf8"));
+  if (auth === null) {
+    throw new Error("No Auth");
   }
-  return {
-    oauthToken: data
-  };
-}
-function isServeseAccount(json) {
-  return "private_key" in json;
+  return auth;
 }
 
 // src/cmd/translate/handler.ts
 var import_async5 = require("async");
-var import_session = require("@yandex-cloud/nodejs-sdk/dist/session");
-var import_service_clients = require("@yandex-cloud/nodejs-sdk/dist/generated/yandex/cloud/service_clients");
-var import_translation_service = require("@yandex-cloud/nodejs-sdk/dist/generated/yandex/cloud/ai/translate/v2/translation_service");
 var REQUESTS_LIMIT = 20;
 var BYTES_LIMIT = 1e4;
 var RETRY_LIMIT = 3;
@@ -4084,12 +4073,10 @@ function handler5(args) {
 }
 function requester(params, cache) {
   const { auth, folderId, sourceLanguage, targetLanguage, dryRun } = params;
-  const session = new import_session.Session(auth);
-  const client = session.client(import_service_clients.TranslationServiceClient);
   const resolve20 = (text, index, texts) => {
     const defer = cache.get(texts[index]);
     if (defer) {
-      defer.resolve([text]);
+      defer.resolve(text);
     }
     return text;
   };
@@ -4101,21 +4088,28 @@ function requester(params, cache) {
         if (dryRun) {
           return texts.map(resolve20);
         }
-        return client.translate(
-          import_translation_service.TranslateRequest.fromPartial({
-            texts,
+        return (0, import_axios.default)({
+          method: "POST",
+          url: "https://translate.api.cloud.yandex.net/translate/v2/translate",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: auth
+          },
+          data: {
             folderId,
+            texts,
             sourceLanguageCode: sourceLanguage,
             targetLanguageCode: targetLanguage,
-            // glossaryConfig: {
-            //     glossaryData: {
-            //         glossaryPairs: yandexCloudTranslateGlossaryPairs,
-            //     },
-            // },
-            format: import_translation_service.TranslateRequest_Format.HTML
-          })
-        ).then((results) => {
-          return results.translations.map(({ text }, index) => {
+            format: "HTML"
+          }
+        }).then(({ data, status }) => {
+          if (status === 200) {
+            return data;
+          } else {
+            throw new Error(data.message);
+          }
+        }).then((result) => {
+          return result.translations.map(({ text }, index) => {
             return resolve20(text, index, texts);
           });
         }).catch((error) => {
@@ -4133,13 +4127,15 @@ function requester(params, cache) {
 }
 function translator(params, split) {
   const { input, output, sourceLanguage, targetLanguage } = params;
+  const inputRoot = (0, import_path34.resolve)(input);
+  const outputRoot = (0, import_path34.resolve)(output);
   return (path) => __async(this, null, function* () {
     const ext = (0, import_path34.extname)(path);
     if (![".yaml", ".json", ".md"].includes(ext)) {
       return;
     }
-    const inputPath = (0, import_path34.resolve)(input, path);
-    const outputPath = (0, import_path34.resolve)(output, path);
+    const inputPath = (0, import_path34.join)(inputRoot, path);
+    const outputPath = (0, import_path34.join)(outputRoot, path.replace(sourceLanguage, targetLanguage));
     const content = yield loadFile(inputPath);
     yield (0, import_promises6.mkdir)((0, import_path34.dirname)(outputPath), { recursive: true });
     if (!content) {
@@ -4160,7 +4156,7 @@ function translator(params, split) {
       yield dumpFile(outputPath, content);
       return;
     }
-    const parts = flat(yield Promise.all(split(path, units)));
+    const parts = yield Promise.all(split(path, units));
     const composed = compose(skeleton, parts, { useSource: true });
     yield dumpFile(outputPath, composed);
   });
@@ -4171,28 +4167,29 @@ function splitter(request, cache) {
     let buffer = [];
     let bufferSize = 0;
     const release = () => {
-      promises.push(backoff(request(buffer)));
+      backoff(request(buffer));
       buffer = [];
       bufferSize = 0;
     };
     for (const text of texts) {
-      const defer = cache.get(text);
-      if (defer) {
-        promises.push(defer.promise);
-      } else if (text.length >= BYTES_LIMIT) {
+      if (text.length >= BYTES_LIMIT) {
         logger.warn(path, "Skip document part for translation. Part is too big.");
-        promises.push(Promise.resolve([text]));
+        promises.push(Promise.resolve(text));
       } else {
-        if (bufferSize + text.length > BYTES_LIMIT) {
-          release();
+        const defer = cache.get(text) || new Defer();
+        promises.push(defer.promise);
+        if (!cache.get(text)) {
+          if (bufferSize + text.length > BYTES_LIMIT) {
+            release();
+          }
+          buffer.push(text);
+          bufferSize += text.length;
         }
-        buffer.push(text);
-        bufferSize += text.length;
-        cache.set(text, new Defer());
+        cache.set(text, defer);
       }
     }
     if (bufferSize) {
-      promises.push(backoff(request(buffer)));
+      release();
     }
     return promises;
   };
@@ -4268,7 +4265,7 @@ import_yargs.default.command(build).command(publish).command(translate).option("
   default: false,
   describe: "Run in quiet mode. Don't write logs to stdout",
   type: "boolean"
-}).group(["config", "strict", "quiet", "help", "version"], "Common options:").version(true ? "4.13.7" : "").help().parse((0, import_helpers.hideBin)(process.argv), {}, (err, { strict }, output) => {
+}).group(["config", "strict", "quiet", "help", "version"], "Common options:").version(true ? "4.13.8" : "").help().parse((0, import_helpers.hideBin)(process.argv), {}, (err, { strict }, output) => {
   console.timeEnd(MAIN_TIMER_ID);
   if (err) {
     console.error(err);