@diplodoc/cli 4.13.6 → 4.13.8

package/build/index.js

@@ -56,7 +56,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve19, reject) => {
+  return new Promise((resolve20, reject) => {
     var fulfilled = (value) => {
       try {
         step(generator.next(value));
@@ -71,7 +71,7 @@ var __async = (__this, __arguments, generator) => {
         reject(e);
       }
     };
-    var step = (x) => x.done ? resolve19(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    var step = (x) => x.done ? resolve20(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
     step((generator = generator.apply(__this, __arguments)).next());
   });
 };
@@ -1878,10 +1878,10 @@ function filterFile(path) {
       resolveConditions: true
     });
     parsedIndex.title = liquidField(title, combinedVars, path);
-    const description6 = filterTextItems(parsedIndex.description, combinedVars, {
+    const description5 = filterTextItems(parsedIndex.description, combinedVars, {
       resolveConditions: true
     });
-    parsedIndex.description = liquidFields(description6, combinedVars, path);
+    parsedIndex.description = liquidFields(description5, combinedVars, path);
     if ((_a = parsedIndex.meta) == null ? void 0 : _a.title) {
       const metaTitle = firstFilterTextItems(parsedIndex.meta.title, combinedVars, {
         resolveConditions: true
@@ -3640,147 +3640,287 @@ function handler2(args) {
   });
 }
 
-// src/cmd/xliff/extract.ts
+// src/cmd/translate/extract.ts
+var import_assert2 = require("assert");
+var import_promises4 = require("fs/promises");
+var import_path32 = require("path");
+var import_async3 = require("async");
+var import_translation3 = require("@diplodoc/translation");
+
+// src/cmd/translate/utils/index.ts
 var import_assert = require("assert");
+var import_path31 = require("path");
+var import_node_fs = require("fs");
 var import_glob4 = __toESM(require("glob"));
+
+// src/cmd/translate/utils/fs.ts
+var import_translation = require("@diplodoc/translation");
 var import_path30 = require("path");
-var import_markdown_translation = require("@diplodoc/markdown-translation");
-var import_async3 = require("async");
-var {
-  promises: { readFile: readFile3, writeFile: writeFile2, mkdir: mkdir2 }
-} = require("fs");
+var import_js_yaml9 = require("js-yaml");
+var import_promises3 = require("fs/promises");
+function parseFile(text, path) {
+  if (typeof text !== "string") {
+    return text;
+  }
+  switch ((0, import_path30.extname)(path)) {
+    case ".yaml":
+      return (0, import_js_yaml9.load)(text);
+    case ".json":
+      return JSON.parse(text);
+    default:
+      return text;
+  }
+}
+function stringifyFile(content, path) {
+  if (typeof content === "string") {
+    return content;
+  }
+  switch ((0, import_path30.extname)(path)) {
+    case ".yaml":
+      return (0, import_js_yaml9.dump)(content);
+    case ".json":
+      return JSON.stringify(content);
+    default:
+      return content;
+  }
+}
+function loadFile(path) {
+  return __async(this, null, function* () {
+    const text = yield (0, import_promises3.readFile)(path, "utf8");
+    let content = parseFile(text, path);
+    if (content && typeof content === "object") {
+      content = yield (0, import_translation.resolveRefs)(content, path, parseFile);
+    }
+    return content;
+  });
+}
+function dumpFile(path, content) {
+  return __async(this, null, function* () {
+    const text = stringifyFile(content, path);
+    yield (0, import_promises3.writeFile)(path, text, "utf8");
+  });
+}
+
+// src/cmd/translate/utils/translate.ts
+var import_translation2 = require("@diplodoc/translation");
+var ExtractError = class extends Error {
+  constructor(error) {
+    super((error == null ? void 0 : error.message) || String(error));
+    this.code = "EXTRACT_ERROR";
+  }
+};
+var ComposeError = class extends Error {
+  constructor(error) {
+    super((error == null ? void 0 : error.message) || String(error));
+    this.code = "COMPOSE_ERROR";
+  }
+};
+function extract2(content, options) {
+  try {
+    const { units, skeleton } = (0, import_translation2.extract)(content, options);
+    return { units, skeleton };
+  } catch (error) {
+    throw new ExtractError(error);
+  }
+}
+function compose(skeleton, xliff, options) {
+  try {
+    return (0, import_translation2.compose)(skeleton, xliff, options);
+  } catch (error) {
+    throw new ComposeError(error);
+  }
+}
+
+// src/cmd/translate/utils/index.ts
+function normalizeParams(params, exts = EXTS) {
+  const source = normalizeLocale(params, "source")[0];
+  const targets = normalizeLocale(params, "target");
+  const { input, files } = normalizeInput(params, source[0], exts);
+  const { output, auth, folder, dryRun, useSource } = params;
+  (0, import_assert.ok)(input, "Required param input is not configured");
+  return {
+    input,
+    output: output || input,
+    auth,
+    folder,
+    source,
+    targets,
+    files: [...new Set(files)],
+    dryRun: Boolean(dryRun),
+    useSource: Boolean(useSource)
+  };
+}
+function normalizeLocale(params, scope) {
+  const _scopeLanguage = params[scope + "Language"];
+  const _scopeLanguageLocale = params[scope + "LanguageLocale"];
+  const _scope = params[scope] || _scopeLanguageLocale || _scopeLanguage;
+  if (!_scope) {
+    return [["", ""]];
+  }
+  if (Array.isArray(_scope)) {
+    return _scope.map((_scope2) => _scope2.split("-"));
+  }
+  return [_scope.split("-")];
+}
+var EXTS = [".md", ".yaml", ".json"];
+function normalizeInput(params, language, exts) {
+  let { input, include = [], exclude = [] } = params;
+  include = [].concat(include);
+  exclude = [].concat(exclude);
+  let files = null;
+  if ((0, import_path31.extname)(input) === ".list") {
+    const list = (0, import_node_fs.readFileSync)(input, "utf8").split("\n");
+    input = (0, import_path31.dirname)(input);
+    files = list.map((file) => {
+      const absPath = (0, import_path31.resolve)(input, file);
+      if (!absPath.startsWith(input)) {
+        throw new Error(`Insecure access to file out of project scope. (file: ${absPath})`);
+      }
+      if (!exts.includes((0, import_path31.extname)(file))) {
+        throw new Error(`Unhandles file extension. (file: ${absPath})`);
+      }
+      return absPath;
+    });
+  } else {
+    if (exts.includes((0, import_path31.extname)(input))) {
+      files = [(0, import_path31.basename)(input)];
+      input = (0, import_path31.dirname)(input);
+    }
+    if (!include.length) {
+      include.push("...");
+    }
+    include = include.reduce((acc, item) => {
+      if (item === "...") {
+        acc.push(...exts.map((ext) => (language || ".") + "/**/*" + ext));
+      } else {
+        acc.push(item);
+      }
+      return acc;
+    }, []);
+    files = files || [].concat(
+      ...include.map(
+        (match) => import_glob4.default.sync(match, {
+          cwd: input,
+          ignore: exclude,
+          nodir: true
+        })
+      )
+    );
+  }
+  return { input, files };
+}
+function resolveSchemas(_path) {
+  return null;
+}
+var Defer = class {
+  constructor() {
+    this.promise = new Promise((resolve20, reject) => {
+      this.resolve = resolve20;
+      this.reject = reject;
+    });
+  }
+};
+function bytes(texts) {
+  return texts.reduce((sum, text) => sum + text.length, 0);
+}
+
+// src/cmd/translate/extract.ts
 var command2 = "extract";
 var description2 = "extract xliff and skeleton from yfm documentation";
-var extract2 = { command: command2, description: description2, handler: handler3, builder: builder3 };
+var extract3 = { command: command2, description: description2, handler: handler3, builder: builder3 };
 var MAX_CONCURRENCY = 50;
 function builder3(argv) {
-  return argv.option("source-language-locale", {
-    alias: "sll",
-    describe: "source language and locale",
-    type: "string"
-  }).option("target-language-locale", {
-    alias: "tll",
-    describe: "target language and locale",
-    type: "string"
-  }).option("input", {
+  return argv.option("input", {
     alias: "i",
-    describe: "input folder with markdown files",
-    type: "string"
+    describe: "input folder with xliff and skeleton files",
+    type: "string",
+    default: process.cwd()
   }).option("output", {
     alias: "o",
-    describe: "output folder to store xliff and skeleton files",
+    describe: "output folder where translated markdown will be stored",
+    type: "string"
+  }).option("source", {
+    alias: ["sll", "source-language-locale"],
+    describe: "source language and locale",
+    type: "string"
+  }).option("target", {
+    alias: ["tll", "target-language-locale"],
+    describe: "target language and locale",
     type: "string"
   }).check(argvValidator);
 }
 function handler3(args) {
   return __async(this, null, function* () {
-    args = Object.assign({}, args.translate || {}, args);
-    delete args.translate;
-    argv_default.init(__spreadValues({}, args));
-    const {
-      output,
-      exclude = [],
-      sourceLanguage,
-      sourceLocale,
-      targetLanguage,
-      targetLocale
-    } = argv_default.getConfig();
-    let {
-      input,
-      include = [],
-      sourceLanguageLocale,
-      targetLanguageLocale
-    } = argv_default.getConfig();
-    (0, import_assert.ok)(input);
-    (0, import_assert.ok)(output);
-    (0, import_assert.ok)(
-      sourceLanguageLocale || sourceLanguage && sourceLocale,
-      "Source language and locale should be configured"
-    );
-    (0, import_assert.ok)(
-      targetLanguageLocale || targetLanguage && targetLocale,
-      "Source language and locale should be configured"
-    );
-    sourceLanguageLocale = sourceLanguageLocale || sourceLanguage + "-" + sourceLocale;
-    targetLanguageLocale = targetLanguageLocale || targetLanguage + "-" + targetLocale;
-    const source = parseLanguageLocale(sourceLanguageLocale);
-    const target = parseLanguageLocale(targetLanguageLocale);
-    if (input.endsWith(".md")) {
-      include = [(0, import_path30.basename)(input)];
-      input = (0, import_path30.dirname)(input);
-    } else if (!include.length) {
-      include.push("**/*");
+    var _a;
+    const params = normalizeParams(__spreadValues(__spreadValues(__spreadValues({}, args.translate || {}), ((_a = args.translate) == null ? void 0 : _a.extract) || {}), args));
+    argv_default.init(params);
+    const { input, output, source, targets, files } = argv_default.getConfig();
+    (0, import_assert2.ok)(source, `Required param source is not configured`);
+    (0, import_assert2.ok)(targets.length, `Required param target is not configured`);
+    for (const target of targets) {
+      const [sourceLanguage, sourceLocale] = source;
+      const [targetLanguage, targetLocale] = target;
+      (0, import_assert2.ok)(sourceLanguage && sourceLocale, "Invalid source language-locale config");
+      (0, import_assert2.ok)(targetLanguage && targetLocale, "Invalid target language-locale config");
+      const configuredPipeline = pipeline2({
+        source: { language: sourceLanguage, locale: sourceLocale },
+        target: { language: targetLanguage, locale: targetLocale },
+        input,
+        output
+      });
+      yield (0, import_async3.eachLimit)(files, MAX_CONCURRENCY, (0, import_async3.asyncify)(configuredPipeline));
     }
-    const files = [].concat(
-      ...include.map(
-        (match) => import_glob4.default.sync(match, {
-          cwd: (0, import_path30.join)(input, source.language),
-          ignore: exclude
-        })
-      )
-    );
-    const found = [...new Set(files)];
-    const configuredPipeline = pipeline2({ source, target, input, output });
-    yield (0, import_async3.eachLimit)(found, MAX_CONCURRENCY, (0, import_async3.asyncify)(configuredPipeline));
   });
 }
-function parseLanguageLocale(languageLocale) {
-  const [language, locale] = languageLocale.split("-");
-  if (!(language == null ? void 0 : language.length) || !(locale == null ? void 0 : locale.length)) {
-    throw new Error("invalid language-locale string");
-  }
-  return { language, locale };
-}
 function pipeline2(params) {
   const { input, output, source, target } = params;
-  const inputRoot = (0, import_path30.resolve)(input, source.language);
-  const outputRoot = (0, import_path30.resolve)(output, target.language);
+  const inputRoot = (0, import_path32.resolve)(input);
+  const outputRoot = (0, import_path32.resolve)(output);
   return (path) => __async(this, null, function* () {
-    if (!path.endsWith(".md")) {
+    const ext = (0, import_path32.extname)(path);
+    if (![".yaml", ".json", ".md"].includes(ext)) {
       return;
     }
-    const inputPath = (0, import_path30.join)(inputRoot, path);
-    const xliffPath = (0, import_path30.join)(outputRoot, path + ".xliff");
-    const skeletonPath = (0, import_path30.join)(outputRoot, path + ".skl");
-    const markdown = yield readFile3(inputPath, "utf-8");
-    yield mkdir2((0, import_path30.dirname)(xliffPath), { recursive: true });
-    const { xliff: xliff2, skeleton } = yield (0, import_markdown_translation.extract)({
-      markdownPath: path,
-      skeletonPath,
-      markdown,
+    const inputPath = (0, import_path32.join)(inputRoot, path);
+    const outputPath = path.replace(source.language, target.language);
+    const xliffPath = (0, import_path32.join)(outputRoot, outputPath + ".xliff");
+    const skeletonPath = (0, import_path32.join)(outputRoot, outputPath + ".skl");
+    let schemas;
+    if ([".yaml", ".json"].includes(ext)) {
+      schemas = resolveSchemas(path);
+      if (!schemas) {
+        return;
+      }
+    }
+    const content = yield loadFile(inputPath);
+    yield (0, import_promises4.mkdir)((0, import_path32.dirname)(xliffPath), { recursive: true });
+    const { xliff, skeleton } = (0, import_translation3.extract)(content, {
       source,
       target
     });
-    yield Promise.all([writeFile2(skeletonPath, skeleton), writeFile2(xliffPath, xliff2)]);
+    yield Promise.all([dumpFile(skeletonPath, skeleton), dumpFile(xliffPath, xliff)]);
   });
 }
 
-// src/cmd/xliff/compose.ts
-var import_assert2 = require("assert");
-var import_glob5 = __toESM(require("glob"));
-var import_path31 = require("path");
-var import_markdown_translation2 = require("@diplodoc/markdown-translation");
+// src/cmd/translate/compose.ts
+var import_promises5 = require("fs/promises");
+var import_path33 = require("path");
 var import_async4 = require("async");
-var {
-  promises: { readFile: readFile4, writeFile: writeFile3, mkdir: mkdir3 }
-} = require("fs");
+var import_translation4 = require("@diplodoc/translation");
 var command3 = "compose";
 var description3 = "compose xliff and skeleton into documentation";
-var compose = { command: command3, description: description3, handler: handler4, builder: builder4 };
+var compose2 = { command: command3, description: description3, handler: handler4, builder: builder4 };
 var MAX_CONCURRENCY2 = 50;
 function builder4(argv) {
   return argv.option("input", {
     alias: "i",
     describe: "input folder with xliff and skeleton files",
-    type: "string"
+    type: "string",
+    default: process.cwd()
   }).option("output", {
     alias: "o",
     describe: "output folder where translated markdown will be stored",
     type: "string"
-  }).option("target-language", {
-    alias: "tl",
-    describe: "target language",
-    type: "string"
   }).option("use-source", {
     describe: "for debug",
     type: "boolean"
@@ -3788,115 +3928,86 @@ function builder4(argv) {
 }
 function handler4(args) {
   return __async(this, null, function* () {
-    args = Object.assign({}, args.translate || {}, args);
-    delete args.translate;
-    argv_default.init(__spreadValues({}, args));
+    var _a;
+    const params = normalizeParams(
+      __spreadValues(__spreadValues(__spreadValues({}, args.translate || {}), ((_a = args.translate) == null ? void 0 : _a.compose) || {}), args),
+      [".skl", ".xliff"]
+    );
+    argv_default.init(params);
     const {
       input,
       output,
-      exclude = [],
-      targetLanguage,
+      files,
       useSource = false
     } = argv_default.getConfig();
-    (0, import_assert2.ok)(input);
-    (0, import_assert2.ok)(output);
-    (0, import_assert2.ok)(targetLanguage);
-    const skeletons = import_glob5.default.sync("**/*.skl", {
-      cwd: (0, import_path31.join)(input, targetLanguage),
-      ignore: exclude
-    });
-    const xliffs = import_glob5.default.sync("**/*.xliff", {
-      cwd: (0, import_path31.join)(input, targetLanguage),
-      ignore: exclude
-    });
-    (0, import_assert2.ok)(xliffs.length === skeletons.length, "Inconsistent number of xliff and skeleton files.");
-    const pipelineParameters = { input, output, targetLanguage, useSource };
-    const configuredPipeline = pipeline3(pipelineParameters);
-    yield (0, import_async4.eachLimit)(skeletons, MAX_CONCURRENCY2, configuredPipeline);
+    const pairs = files.reduce(
+      (acc, file) => {
+        const ext = (0, import_path33.extname)(file);
+        const path = file.slice(0, -ext.length);
+        acc[path] = acc[path] || { path, ext };
+        acc[path][ext.slice(1)] = file;
+        return acc;
+      },
+      {}
+    );
+    const configuredPipeline = pipeline3(input, output, { useSource });
+    yield (0, import_async4.eachLimit)(pairs, MAX_CONCURRENCY2, configuredPipeline);
   });
 }
-function pipeline3(params) {
-  const { input, output, targetLanguage, useSource } = params;
-  return (skeletonPath) => __async(this, null, function* () {
-    const fileName = skeletonPath.split(".").slice(0, -1).join(".");
-    const xliffPath = fileName + ".xliff";
-    const [skeleton, xliff2] = yield Promise.all([
-      readFile4((0, import_path31.join)(input, targetLanguage, skeletonPath), "utf-8"),
-      readFile4((0, import_path31.join)(input, targetLanguage, xliffPath), "utf-8")
+function pipeline3(input, output, { useSource }) {
+  return (file) => __async(this, null, function* () {
+    const [skeleton, xliff] = yield Promise.all([
+      loadFile((0, import_path33.join)(input, file.skl)),
+      loadFile((0, import_path33.join)(input, file.xliff))
     ]);
-    const markdown = (0, import_markdown_translation2.compose)({
-      skeleton,
-      xliff: xliff2,
-      skeletonPath,
-      xliffPath,
-      useSource
-    });
-    const markdownPath = (0, import_path31.join)(output, targetLanguage, fileName);
-    yield mkdir3((0, import_path31.dirname)(markdownPath), { recursive: true });
-    yield writeFile3(markdownPath, markdown);
+    let schemas;
+    if ([".yaml", ".json"].includes(file.ext)) {
+      schemas = resolveSchemas(file.path);
+      if (!schemas) {
+        return;
+      }
+    }
+    const result = (0, import_translation4.compose)(skeleton, xliff, { useSource, schemas });
+    const filePath = (0, import_path33.join)(output, file.path);
+    yield (0, import_promises5.mkdir)((0, import_path33.dirname)(filePath), { recursive: true });
+    yield dumpFile(filePath, result);
   });
 }
 
-// src/cmd/xliff/index.ts
-var command4 = "xliff";
-var description4 = "extract xliff and skeleton from documentation files\ncompose xliff and skeleton into documentation";
-var xliff = {
-  command: command4,
-  description: description4,
-  handler: () => {
-  },
-  builder: builder5
-};
-function builder5(argv) {
-  return argv.command(extract2).command(compose).demandCommand(
-    1,
-    `provide one of the folowing ${command4} commands: ${extract2.command}, ${compose.command}`
-  );
-}
-
 // src/cmd/translate/handler.ts
+var import_axios = __toESM(require("axios"));
 var import_assert3 = require("assert");
-var import_path33 = require("path");
-var import_glob6 = __toESM(require("glob"));
+var import_path34 = require("path");
+var import_promises6 = require("fs/promises");
 
-// src/packages/credentials/yandex-oauth.ts
-var import_promises3 = require("fs/promises");
-var import_process3 = require("process");
-var import_os = require("os");
-var import_path32 = require("path");
-var YANDEX_OAUTH_TOKEN_FILENAME = ".ya_oauth_token";
-function getYandexOAuthToken() {
-  return __async(this, null, function* () {
-    const { YANDEX_OAUTH_TOKEN } = import_process3.env;
-    return YANDEX_OAUTH_TOKEN != null ? YANDEX_OAUTH_TOKEN : getYandexOAuthTokenFromHomeDir();
-  });
-}
-function getYandexOAuthTokenFromHomeDir() {
-  return __async(this, null, function* () {
-    const error = "failed reading yandex oauth token";
-    const path = (0, import_path32.join)((0, import_os.homedir)(), YANDEX_OAUTH_TOKEN_FILENAME);
-    let token;
-    try {
-      token = yield (0, import_promises3.readFile)(path, { encoding: "utf8" });
-      token = token.trim();
-      if (!(token == null ? void 0 : token.length)) {
-        throw new Error(error);
-      }
-    } catch (err) {
-      logger.error(error);
-      throw err;
-    }
-    return token;
-  });
+// 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) {
+  let auth = resolveKey(path);
+  if (auth !== null) {
+    return auth;
+  }
+  auth = resolveKey((0, import_fs14.readFileSync)(path, "utf8"));
+  if (auth === null) {
+    throw new Error("No Auth");
+  }
+  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 import_promises4 = require("fs/promises");
-var import_markdown_translation3 = require("@diplodoc/markdown-translation");
 var REQUESTS_LIMIT = 20;
 var BYTES_LIMIT = 1e4;
 var RETRY_LIMIT = 3;
@@ -3906,230 +4017,225 @@ var TranslatorError = class extends Error {
     this.path = path;
   }
 };
+var RequestError = class extends Error {
+  constructor(error) {
+    super((error == null ? void 0 : error.message) || String(error));
+    this.code = "REQUEST_ERROR";
+  }
+};
 function handler5(args) {
   return __async(this, null, function* () {
-    argv_default.init(__spreadValues(__spreadValues({}, args.translate || {}), args));
-    const {
-      folderId,
-      // yandexCloudTranslateGlossaryPairs,
-      sourceLanguage,
-      targetLanguage,
-      exclude = []
-    } = argv_default.getConfig();
-    let { input, output, include = [] } = argv_default.getConfig();
-    logger.info(
-      input,
-      `translating documentation from ${sourceLanguage} to ${targetLanguage} language`
-    );
-    output = output || input;
-    (0, import_assert3.ok)(input, "Required param input is not configured");
-    (0, import_assert3.ok)(sourceLanguage, "Required param sourceLanguage is not configured");
-    (0, import_assert3.ok)(targetLanguage, "Required param targetLanguage is not configured");
+    const params = normalizeParams(__spreadValues(__spreadValues({}, args.translate || {}), args));
+    argv_default.init(params);
+    const { input, output, auth, folder, source, targets, files, dryRun } = argv_default.getConfig();
+    (0, import_assert3.ok)(auth, "Required param auth is not configured");
+    (0, import_assert3.ok)(folder, "Required param folder is not configured");
+    (0, import_assert3.ok)(source, `Required param source is not configured`);
+    (0, import_assert3.ok)(targets.length, `Required param target is not configured`);
     try {
-      if (input.endsWith(".md")) {
-        include = [(0, import_path33.basename)(input)];
-        input = (0, import_path33.dirname)(input);
-      } else if (!include.length) {
-        include.push("**/*");
-      }
-      const files = [].concat(
-        ...include.map(
-          (match) => import_glob6.default.sync(match, {
-            cwd: (0, import_path33.join)(input, sourceLanguage),
-            ignore: exclude
+      const authInfo = getYandexAuth(auth);
+      for (const target of targets) {
+        const translatorParams = {
+          input,
+          output,
+          sourceLanguage: source[0],
+          targetLanguage: target[0],
+          // yandexCloudTranslateGlossaryPairs,
+          folderId: folder,
+          auth: authInfo,
+          dryRun
+        };
+        const cache = /* @__PURE__ */ new Map();
+        const request = requester(translatorParams, cache);
+        const split = splitter(request, cache);
+        const translate2 = translator(translatorParams, split);
+        yield (0, import_async5.eachLimit)(
+          files,
+          REQUESTS_LIMIT,
+          (0, import_async5.asyncify)(function(file) {
+            return __async(this, null, function* () {
+              try {
+                yield translate2(file);
+              } catch (error) {
+                logger.error(file, error.message);
+              }
+            });
           })
-        )
-      );
-      const found = [...new Set(files)];
-      const oauthToken = yield getYandexOAuthToken();
-      const translatorParams = {
-        input,
-        output,
-        sourceLanguage,
-        targetLanguage,
-        // yandexCloudTranslateGlossaryPairs,
-        folderId,
-        oauthToken
-      };
-      const translateFn = translator(translatorParams);
-      yield (0, import_async5.eachLimit)(found, REQUESTS_LIMIT, (0, import_async5.asyncify)(translateFn));
-    } catch (err) {
-      if (err instanceof Error || err instanceof TranslatorError) {
-        const message = err.message;
-        const file = err instanceof TranslatorError ? err.path : "";
-        logger.error(file, message);
+        );
+        console.log("PROCESSED", `bytes: ${request.stat.bytes} chunks: ${request.stat.chunks}`);
       }
+    } catch (error) {
+      const message = error.message;
+      const file = error instanceof TranslatorError ? error.path : "";
+      logger.error(file, message);
     }
-    logger.info(
-      output,
-      `translated documentation from ${sourceLanguage} to ${targetLanguage} language`
-    );
   });
 }
-function translator(params) {
-  const {
-    oauthToken,
-    folderId,
-    input,
-    output,
-    sourceLanguage,
-    targetLanguage
-    // yandexCloudTranslateGlossaryPairs,
-  } = params;
-  const tmap = /* @__PURE__ */ new Map();
-  const session = new import_session.Session({ oauthToken });
-  const client = session.client(import_service_clients.TranslationServiceClient);
-  const request = (texts) => () => {
-    return client.translate(
-      import_translation_service.TranslateRequest.fromPartial({
-        texts,
-        folderId,
-        sourceLanguageCode: sourceLanguage,
-        targetLanguageCode: targetLanguage,
-        // glossaryConfig: {
-        //     glossaryData: {
-        //         glossaryPairs: yandexCloudTranslateGlossaryPairs,
-        //     },
-        // },
-        format: import_translation_service.TranslateRequest_Format.HTML
-      })
-    ).then((results) => {
-      return results.translations.map(({ text }, index) => {
-        const defer = tmap.get(texts[index]);
-        if (defer) {
-          defer.resolve([text]);
+function requester(params, cache) {
+  const { auth, folderId, sourceLanguage, targetLanguage, dryRun } = params;
+  const resolve20 = (text, index, texts) => {
+    const defer = cache.get(texts[index]);
+    if (defer) {
+      defer.resolve(text);
+    }
+    return text;
+  };
+  const request = function request2(texts) {
+    request2.stat.bytes += bytes(texts);
+    request2.stat.chunks++;
+    return function() {
+      return __async(this, null, function* () {
+        if (dryRun) {
+          return texts.map(resolve20);
         }
-        return text;
+        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,
+            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) => {
+          console.error(error);
+          throw new RequestError(error);
+        });
       });
-    });
+    };
+  };
+  request.stat = {
+    bytes: 0,
+    chunks: 0
   };
-  return (mdPath) => __async(this, null, function* () {
-    if (!mdPath.endsWith(".md")) {
+  return request;
+}
+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;
     }
-    try {
-      logger.info(mdPath, "translating");
-      const inputPath = (0, import_path33.resolve)(input, sourceLanguage, mdPath);
-      const outputPath = (0, import_path33.resolve)(output, targetLanguage, mdPath);
-      const md = yield (0, import_promises4.readFile)(inputPath, { encoding: "utf-8" });
-      yield (0, import_promises4.mkdir)((0, import_path33.dirname)(outputPath), { recursive: true });
-      if (!md) {
-        yield (0, import_promises4.writeFile)(outputPath, md);
-        return;
-      }
-      const { units, skeleton } = (0, import_markdown_translation3.extract)({
-        source: {
-          language: sourceLanguage,
-          locale: "RU"
-        },
-        target: {
-          language: targetLanguage,
-          locale: "US"
-        },
-        markdown: md,
-        markdownPath: mdPath,
-        skeletonPath: ""
-      });
-      if (!units.length) {
-        yield (0, import_promises4.writeFile)(outputPath, md);
-        return;
+    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) {
+      yield dumpFile(outputPath, content);
+      return;
+    }
+    const { units, skeleton } = extract2(content, {
+      source: {
+        language: sourceLanguage,
+        locale: "RU"
+      },
+      target: {
+        language: targetLanguage,
+        locale: "US"
       }
-      const parts = yield Promise.all(
-        units.reduce(
-          ({
-            promises,
-            buffer,
-            bufferSize
-          }, text, index) => {
-            if (text.length >= BYTES_LIMIT) {
-              logger.warn(
-                mdPath,
-                "Skip document part for translation. Part is too big."
-              );
-              promises.push(Promise.resolve([text]));
-              return { promises, buffer, bufferSize };
-            }
-            const defer = tmap.get(text);
-            if (defer) {
-              console.log("SKIPPED", text);
-              promises.push(defer.promise);
-              return { promises, buffer, bufferSize };
-            }
-            if (bufferSize + text.length > BYTES_LIMIT) {
-              promises.push(backoff(request(buffer)));
-              buffer = [];
-              bufferSize = 0;
-            }
-            buffer.push(text);
-            bufferSize += text.length;
-            tmap.set(text, new Defer());
-            if (index === units.length - 1) {
-              promises.push(backoff(request(buffer)));
-            }
-            return { promises, buffer, bufferSize };
-          },
-          {
-            promises: [],
-            buffer: [],
-            bufferSize: 0
+    });
+    if (!units.length) {
+      yield dumpFile(outputPath, content);
+      return;
+    }
+    const parts = yield Promise.all(split(path, units));
+    const composed = compose(skeleton, parts, { useSource: true });
+    yield dumpFile(outputPath, composed);
+  });
+}
+function splitter(request, cache) {
+  return function(path, texts) {
+    const promises = [];
+    let buffer = [];
+    let bufferSize = 0;
+    const release = () => {
+      backoff(request(buffer));
+      buffer = [];
+      bufferSize = 0;
+    };
+    for (const text of texts) {
+      if (text.length >= BYTES_LIMIT) {
+        logger.warn(path, "Skip document part for translation. Part is too big.");
+        promises.push(Promise.resolve(text));
+      } else {
+        const defer = cache.get(text) || new Defer();
+        promises.push(defer.promise);
+        if (!cache.get(text)) {
+          if (bufferSize + text.length > BYTES_LIMIT) {
+            release();
           }
-        ).promises
-      );
-      const translations = [].concat(...parts);
-      const composed = yield (0, import_markdown_translation3.compose)({
-        useSource: true,
-        units: translations,
-        skeleton
-      });
-      yield (0, import_promises4.writeFile)(outputPath, composed);
-      logger.info(outputPath, "finished translating");
-    } catch (err) {
-      if (err instanceof Error) {
-        throw new TranslatorError(err.toString(), mdPath);
+          buffer.push(text);
+          bufferSize += text.length;
+        }
+        cache.set(text, defer);
       }
     }
-  });
+    if (bufferSize) {
+      release();
+    }
+    return promises;
+  };
 }
 function backoff(action) {
   return (0, import_async5.retry)(
     {
       times: RETRY_LIMIT,
-      interval: (count) => {
-        return (1 << count) * 1e3;
-      }
+      interval: (count) => Math.pow(2, count) * 1e3
     },
     (0, import_async5.asyncify)(action)
   );
 }
-var Defer = class {
-  constructor() {
-    this.promise = new Promise((resolve19, reject) => {
-      this.resolve = resolve19;
-      this.reject = reject;
-    });
-  }
-};
 
 // src/cmd/translate/index.ts
-var command5 = "translate";
-var description5 = "translate documentation with Yandex.Cloud Translator API";
+var command4 = "translate";
+var description4 = "translate documentation with Yandex.Cloud Translator API";
 var translate = {
-  command: command5,
-  description: description5,
+  command: command4,
+  description: description4,
   handler: handler5,
-  builder: builder6
+  builder: builder5
 };
-function builder6(argv) {
-  return argv.command(extract2).command(compose).option("folder-id", {
-    describe: "folder id",
+function builder5(argv) {
+  return argv.command(extract3).command(compose2).option("input", {
+    alias: "i",
+    describe: "input folder with markdown files",
+    type: "string",
+    default: process.cwd()
+  }).option("output", {
+    alias: "o",
+    describe: "output folder to store xliff and skeleton files",
     type: "string"
-  }).option("source-language", {
-    alias: "sl",
-    describe: "source language code",
+  }).option("auth", {
+    describe: "auth credentials path",
     type: "string"
-  }).option("target-language", {
-    alias: "tl",
-    describe: "target language code",
+  }).option("folder", {
+    describe: "folder",
+    type: "string"
+  }).option("source", {
+    alias: ["sl", "sll", "source-language", "source-language-locale"],
+    describe: "source language and locale",
+    type: "string"
+  }).option("target", {
+    alias: ["tl", "tll", "target-language", "target-language-locale"],
+    describe: "target language and locale",
     type: "string"
   }).option("include", {
     describe: "relative to input globs to include in processing",
@@ -4137,12 +4243,15 @@ function builder6(argv) {
   }).option("exclude", {
     describe: "relative to input globs to exclude from processing",
     type: "string"
+  }).option("dry-run", {
+    describe: "check command usage",
+    type: "boolean"
   }).check(argvValidator);
 }
 
 // src/index.ts
 console.time(MAIN_TIMER_ID);
-import_yargs.default.command(build).command(publish).command(xliff).command(translate).option("config", {
+import_yargs.default.command(build).command(publish).command(translate).option("config", {
   alias: "c",
   describe: "YFM configuration file",
   type: "string"
@@ -4156,7 +4265,7 @@ import_yargs.default.command(build).command(publish).command(xliff).command(tran
   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.6" : "").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);