gt 2.14.35 → 2.14.36

package/dist/api/downloadFileBatch.js

@@ -1,251 +1,174 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { logger } from '../console/logger.js';
-import { gt } from '../utils/gt.js';
-import { validateJsonSchema } from '../formats/json/utils.js';
-import { validateYamlSchema } from '../formats/yaml/utils.js';
-import { mergeJson } from '../formats/json/mergeJson.js';
-import { extractJson } from '../formats/json/extractJson.js';
-import mergeYaml from '../formats/yaml/mergeYaml.js';
-import { extractYaml } from '../formats/yaml/extractYaml.js';
-import { resolveMintlifyRefs, shouldResolveRefs, } from '../utils/resolveMintlifyRefs.js';
-import { readLockfile, writeLockfile, findOrCreateEntry, } from '../fs/config/downloadedVersions.js';
-import { recordDownloaded, recordRemerged } from '../state/recentDownloads.js';
-import { recordWarning } from '../state/translateWarnings.js';
-import stringify from 'fast-json-stable-stringify';
-import { SUPPORTED_FILE_EXTENSIONS } from '../formats/files/supportedFiles.js';
-import { hasNonIdentityFileFormatTransformForType } from '../formats/files/transformFormat.js';
-import { getRelative } from '../fs/findFilepath.js';
+import { logger } from "../console/logger.js";
+import { gt } from "../utils/gt.js";
+import { getRelative } from "../fs/findFilepath.js";
+import { SUPPORTED_FILE_EXTENSIONS } from "../formats/files/supportedFiles.js";
+import { hasNonIdentityFileFormatTransformForType } from "../formats/files/transformFormat.js";
+import { validateJsonSchema } from "../formats/json/utils.js";
+import { extractJson } from "../formats/json/extractJson.js";
+import { resolveMintlifyRefs, shouldResolveRefs } from "../utils/resolveMintlifyRefs.js";
+import { recordWarning } from "../state/translateWarnings.js";
+import { validateYamlSchema } from "../formats/yaml/utils.js";
+import { findOrCreateEntry, readLockfile, writeLockfile } from "../fs/config/downloadedVersions.js";
+import { extractYaml } from "../formats/yaml/extractYaml.js";
+import { mergeJson } from "../formats/json/mergeJson.js";
+import mergeYaml from "../formats/yaml/mergeYaml.js";
+import { recordDownloaded, recordRemerged } from "../state/recentDownloads.js";
+import * as fs$1 from "fs";
+import * as path$1 from "path";
+import stringify from "fast-json-stable-stringify";
+//#region src/api/downloadFileBatch.ts
 function sortJsonString(data) {
-    const sortedData = stringify(JSON.parse(data));
-    return JSON.stringify(JSON.parse(sortedData), null, 2);
+	const sortedData = stringify(JSON.parse(data));
+	return JSON.stringify(JSON.parse(sortedData), null, 2);
 }
 /**
- * Merges translated content with the current source file for schema-based formats.
- */
+* Merges translated content with the current source file for schema-based formats.
+*/
 function mergeWithSource(translatedContent, locale, inputPath, options) {
-    if (shouldSkipSourceFormatMerge(inputPath, options)) {
-        return translatedContent;
-    }
-    if (!options.options)
-        return translatedContent;
-    const jsonSchema = options.options.jsonSchema
-        ? validateJsonSchema(options.options, inputPath)
-        : null;
-    const yamlSchema = !jsonSchema && options.options.yamlSchema
-        ? validateYamlSchema(options.options, inputPath)
-        : null;
-    if (!jsonSchema && !yamlSchema)
-        return translatedContent;
-    const sourceContent = fs.readFileSync(inputPath, 'utf8');
-    if (!sourceContent)
-        return translatedContent;
-    if (jsonSchema) {
-        // Resolve $ref before merging if configured
-        let resolvedSourceContent = sourceContent;
-        if (shouldResolveRefs(inputPath, options.options)) {
-            try {
-                const json = JSON.parse(sourceContent);
-                const { resolved } = resolveMintlifyRefs(json, inputPath);
-                resolvedSourceContent = JSON.stringify(resolved, null, 2);
-            }
-            catch {
-                // Fall through with original content
-            }
-        }
-        return mergeJson(resolvedSourceContent, inputPath, options.options, [{ translatedContent, targetLocale: locale }], options.defaultLocale, options.locales)[0];
-    }
-    else {
-        return mergeYaml(sourceContent, inputPath, options.options, [{ translatedContent, targetLocale: locale }], options.defaultLocale)[0];
-    }
+	if (shouldSkipSourceFormatMerge(inputPath, options)) return translatedContent;
+	if (!options.options) return translatedContent;
+	const jsonSchema = options.options.jsonSchema ? validateJsonSchema(options.options, inputPath) : null;
+	const yamlSchema = !jsonSchema && options.options.yamlSchema ? validateYamlSchema(options.options, inputPath) : null;
+	if (!jsonSchema && !yamlSchema) return translatedContent;
+	const sourceContent = fs$1.readFileSync(inputPath, "utf8");
+	if (!sourceContent) return translatedContent;
+	if (jsonSchema) {
+		let resolvedSourceContent = sourceContent;
+		if (shouldResolveRefs(inputPath, options.options)) try {
+			const { resolved } = resolveMintlifyRefs(JSON.parse(sourceContent), inputPath);
+			resolvedSourceContent = JSON.stringify(resolved, null, 2);
+		} catch {}
+		return mergeJson(resolvedSourceContent, inputPath, options.options, [{
+			translatedContent,
+			targetLocale: locale
+		}], options.defaultLocale, options.locales)[0];
+	} else return mergeYaml(sourceContent, inputPath, options.options, [{
+		translatedContent,
+		targetLocale: locale
+	}], options.defaultLocale)[0];
 }
 /**
- * Determines whether a source file should be skipped for schema re-merging.
- * @param inputPath - The path of the source file
- * @param options - The settings for the project
- * @returns True if the source file should be skipped for schema re-merging, false otherwise
- */
+* Determines whether a source file should be skipped for schema re-merging.
+* @param inputPath - The path of the source file
+* @param options - The settings for the project
+* @returns True if the source file should be skipped for schema re-merging, false otherwise
+*/
 function shouldSkipSourceFormatMerge(inputPath, options) {
-    for (const fileType of SUPPORTED_FILE_EXTENSIONS) {
-        if (!hasNonIdentityFileFormatTransformForType(options, fileType))
-            continue;
-        const transformedSourcePaths = options.files.resolvedPaths[fileType] || [];
-        if (transformedSourcePaths.some((sourcePath) => getRelative(sourcePath) === inputPath)) {
-            return true;
-        }
-    }
-    return false;
+	for (const fileType of SUPPORTED_FILE_EXTENSIONS) {
+		if (!hasNonIdentityFileFormatTransformForType(options, fileType)) continue;
+		if ((options.files.resolvedPaths[fileType] || []).some((sourcePath) => getRelative(sourcePath) === inputPath)) return true;
+	}
+	return false;
 }
 /**
- * Downloads multiple translation files in a single batch request
- * @param files - Array of files to download with their output paths
- * @param maxRetries - Maximum number of retry attempts
- * @param retryDelay - Delay between retries in milliseconds
- * @returns Object containing successful and failed file IDs
- */
-export async function downloadFileBatch(fileTracker, files, options, forceDownload = false) {
-    // Local record of what version was last downloaded for each fileName:locale
-    const { data: downloadedVersions, entryMap, originalV1, } = readLockfile(options);
-    let didUpdateDownloadedLock = false;
-    // Create a map of requested file keys to the file object
-    const requestedFileMap = new Map(files.map((file) => [
-        `${file.branchId}:${file.fileId}:${file.versionId}:${file.locale}`,
-        file,
-    ]));
-    const result = {
-        successful: [],
-        failed: [],
-        skipped: [],
-    };
-    // Create a map of translationId to outputPath for easier lookup
-    const outputPathMap = new Map(files.map((file) => [
-        `${file.branchId}:${file.fileId}:${file.versionId}:${file.locale}`,
-        file.outputPath,
-    ]));
-    try {
-        // Download the files
-        const responseData = await gt.downloadFileBatch(files.map((file) => ({
-            fileId: file.fileId,
-            branchId: file.branchId,
-            versionId: file.versionId,
-            locale: file.locale,
-        })));
-        const downloadedFiles = responseData.files || [];
-        // Process each file in the response
-        for (const file of downloadedFiles) {
-            const fileKey = `${file.branchId}:${file.fileId}:${file.versionId}:${file.locale}`;
-            const requestedFile = requestedFileMap.get(fileKey);
-            if (!requestedFile) {
-                continue;
-            }
-            try {
-                const outputPath = outputPathMap.get(fileKey);
-                const fileProperties = fileTracker.completed.get(fileKey);
-                if (!outputPath || !fileProperties) {
-                    logger.warn(`No input/output path found for file: ${fileKey}`);
-                    recordWarning('failed_download', fileKey, 'No input/output path found');
-                    result.failed.push(requestedFile);
-                    continue;
-                }
-                const { fileId, versionId, locale, branchId, fileName: inputPath, } = fileProperties;
-                // Ensure the directory exists
-                const dir = path.dirname(outputPath);
-                if (!fs.existsSync(dir)) {
-                    fs.mkdirSync(dir, { recursive: true });
-                }
-                // If a local translation already exists for the same source version, skip overwrite
-                const existingEntry = entryMap.get(fileId);
-                const downloadedTranslation = existingEntry?.versionId === versionId
-                    ? existingEntry.translations[locale]
-                    : undefined;
-                const fileExists = fs.existsSync(outputPath);
-                if (!forceDownload && fileExists && downloadedTranslation) {
-                    // For schema-based files, re-merge with current source in case
-                    // non-translatable fields changed (skip the API download, not the merge)
-                    try {
-                        let existingContent = fs.readFileSync(outputPath, 'utf8');
-                        // Resolve $ref before extraction if configured
-                        if (shouldResolveRefs(outputPath, options.options)) {
-                            try {
-                                const json = JSON.parse(existingContent);
-                                const { resolved } = resolveMintlifyRefs(json, outputPath);
-                                existingContent = JSON.stringify(resolved, null, 2);
-                            }
-                            catch {
-                                // Fall through with original content
-                            }
-                        }
-                        const jsonExtracted = options.options?.jsonSchema
-                            ? extractJson(existingContent, inputPath, options.options, locale, options.defaultLocale)
-                            : null;
-                        const extracted = jsonExtracted ??
-                            (options.options?.yamlSchema
-                                ? extractYaml(existingContent, inputPath, options.options)
-                                : null);
-                        if (extracted) {
-                            const remerged = mergeWithSource(extracted, locale, inputPath, options);
-                            let remergedData = remerged;
-                            if (outputPath.endsWith('.json')) {
-                                try {
-                                    remergedData = sortJsonString(remergedData);
-                                }
-                                catch {
-                                    // Fall through with unsorted content
-                                }
-                            }
-                            if (remergedData !== existingContent) {
-                                await fs.promises.writeFile(outputPath, remergedData);
-                            }
-                            // Track for postprocessing (e.g. openapi path localization)
-                            // even when the API download was skipped
-                            recordRemerged(outputPath);
-                        }
-                    }
-                    catch {
-                        // If re-merge fails, still count as skipped — not worth failing the download
-                    }
-                    result.skipped.push(requestedFile);
-                    continue;
-                }
-                let data = mergeWithSource(file.data, locale, inputPath, options);
-                // Stable sort JSON keys for deterministic output
-                if (file.fileFormat === 'GTJSON' || outputPath.endsWith('.json')) {
-                    try {
-                        data = sortJsonString(data);
-                    }
-                    catch (error) {
-                        logger.warn(`Failed to sort JSON file: ${file.id}: ` + error);
-                    }
-                }
-                // Write the file to disk
-                await fs.promises.writeFile(outputPath, data);
-                // Track as downloaded with metadata for downstream postprocessing
-                recordDownloaded(outputPath, {
-                    branchId,
-                    fileId,
-                    versionId,
-                    locale,
-                    inputPath,
-                });
-                result.successful.push(requestedFile);
-                if (fileId && versionId && locale) {
-                    const entry = findOrCreateEntry(entryMap, downloadedVersions.entries, fileId, versionId);
-                    entry.fileName = inputPath;
-                    entry.staged = false;
-                    entry.translations[locale] = {
-                        updatedAt: new Date().toISOString(),
-                        fileName: outputPath,
-                    };
-                    didUpdateDownloadedLock = true;
-                }
-            }
-            catch (error) {
-                logger.error(`Error saving file ${fileKey}: ` + error);
-                recordWarning('failed_download', fileKey, `Error saving file: ${error}`);
-                result.failed.push(requestedFile);
-            }
-        }
-        // Add any files that weren't in the response to the failed list
-        const downloadedFileKeys = new Set(downloadedFiles.map((file) => `${file.branchId}:${file.fileId}:${file.versionId}:${file.locale}`));
-        for (const [fileKey, requestedFile] of requestedFileMap.entries()) {
-            if (!downloadedFileKeys.has(fileKey)) {
-                result.failed.push(requestedFile);
-            }
-        }
-        // Persist any updates to the downloaded map at the end of a successful cycle
-        if (didUpdateDownloadedLock) {
-            writeLockfile(downloadedVersions, originalV1);
-            didUpdateDownloadedLock = false;
-        }
-        return result;
-    }
-    catch (error) {
-        logger.error(`An unexpected error occurred while downloading files: ` + error);
-    }
-    // Mark all files as failed if we get here
-    result.failed = [...requestedFileMap.values()];
-    if (didUpdateDownloadedLock) {
-        writeLockfile(downloadedVersions, originalV1);
-    }
-    return result;
+* Downloads multiple translation files in a single batch request
+* @param files - Array of files to download with their output paths
+* @param maxRetries - Maximum number of retry attempts
+* @param retryDelay - Delay between retries in milliseconds
+* @returns Object containing successful and failed file IDs
+*/
+async function downloadFileBatch(fileTracker, files, options, forceDownload = false) {
+	const { data: downloadedVersions, entryMap, originalV1 } = readLockfile(options);
+	let didUpdateDownloadedLock = false;
+	const requestedFileMap = new Map(files.map((file) => [`${file.branchId}:${file.fileId}:${file.versionId}:${file.locale}`, file]));
+	const result = {
+		successful: [],
+		failed: [],
+		skipped: []
+	};
+	const outputPathMap = new Map(files.map((file) => [`${file.branchId}:${file.fileId}:${file.versionId}:${file.locale}`, file.outputPath]));
+	try {
+		const downloadedFiles = (await gt.downloadFileBatch(files.map((file) => ({
+			fileId: file.fileId,
+			branchId: file.branchId,
+			versionId: file.versionId,
+			locale: file.locale
+		})))).files || [];
+		for (const file of downloadedFiles) {
+			const fileKey = `${file.branchId}:${file.fileId}:${file.versionId}:${file.locale}`;
+			const requestedFile = requestedFileMap.get(fileKey);
+			if (!requestedFile) continue;
+			try {
+				const outputPath = outputPathMap.get(fileKey);
+				const fileProperties = fileTracker.completed.get(fileKey);
+				if (!outputPath || !fileProperties) {
+					logger.warn(`No input/output path found for file: ${fileKey}`);
+					recordWarning("failed_download", fileKey, "No input/output path found");
+					result.failed.push(requestedFile);
+					continue;
+				}
+				const { fileId, versionId, locale, branchId, fileName: inputPath } = fileProperties;
+				const dir = path$1.dirname(outputPath);
+				if (!fs$1.existsSync(dir)) fs$1.mkdirSync(dir, { recursive: true });
+				const existingEntry = entryMap.get(fileId);
+				const downloadedTranslation = existingEntry?.versionId === versionId ? existingEntry.translations[locale] : void 0;
+				const fileExists = fs$1.existsSync(outputPath);
+				if (!forceDownload && fileExists && downloadedTranslation) {
+					try {
+						let existingContent = fs$1.readFileSync(outputPath, "utf8");
+						if (shouldResolveRefs(outputPath, options.options)) try {
+							const { resolved } = resolveMintlifyRefs(JSON.parse(existingContent), outputPath);
+							existingContent = JSON.stringify(resolved, null, 2);
+						} catch {}
+						const extracted = (options.options?.jsonSchema ? extractJson(existingContent, inputPath, options.options, locale, options.defaultLocale) : null) ?? (options.options?.yamlSchema ? extractYaml(existingContent, inputPath, options.options) : null);
+						if (extracted) {
+							let remergedData = mergeWithSource(extracted, locale, inputPath, options);
+							if (outputPath.endsWith(".json")) try {
+								remergedData = sortJsonString(remergedData);
+							} catch {}
+							if (remergedData !== existingContent) await fs$1.promises.writeFile(outputPath, remergedData);
+							recordRemerged(outputPath);
+						}
+					} catch {}
+					result.skipped.push(requestedFile);
+					continue;
+				}
+				let data = mergeWithSource(file.data, locale, inputPath, options);
+				if (file.fileFormat === "GTJSON" || outputPath.endsWith(".json")) try {
+					data = sortJsonString(data);
+				} catch (error) {
+					logger.warn(`Failed to sort JSON file: ${file.id}: ` + error);
+				}
+				await fs$1.promises.writeFile(outputPath, data);
+				recordDownloaded(outputPath, {
+					branchId,
+					fileId,
+					versionId,
+					locale,
+					inputPath
+				});
+				result.successful.push(requestedFile);
+				if (fileId && versionId && locale) {
+					const entry = findOrCreateEntry(entryMap, downloadedVersions.entries, fileId, versionId);
+					entry.fileName = inputPath;
+					entry.staged = false;
+					entry.translations[locale] = {
+						updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+						fileName: outputPath
+					};
+					didUpdateDownloadedLock = true;
+				}
+			} catch (error) {
+				logger.error(`Error saving file ${fileKey}: ` + error);
+				recordWarning("failed_download", fileKey, `Error saving file: ${error}`);
+				result.failed.push(requestedFile);
+			}
+		}
+		const downloadedFileKeys = new Set(downloadedFiles.map((file) => `${file.branchId}:${file.fileId}:${file.versionId}:${file.locale}`));
+		for (const [fileKey, requestedFile] of requestedFileMap.entries()) if (!downloadedFileKeys.has(fileKey)) result.failed.push(requestedFile);
+		if (didUpdateDownloadedLock) {
+			writeLockfile(downloadedVersions, originalV1);
+			didUpdateDownloadedLock = false;
+		}
+		return result;
+	} catch (error) {
+		logger.error(`An unexpected error occurred while downloading files: ` + error);
+	}
+	result.failed = [...requestedFileMap.values()];
+	if (didUpdateDownloadedLock) writeLockfile(downloadedVersions, originalV1);
+	return result;
 }
+//#endregion
+export { downloadFileBatch };
+
+//# sourceMappingURL=downloadFileBatch.js.map

package/dist/api/downloadFileBatch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"downloadFileBatch.js","names":["fs","path"],"sources":["../../src/api/downloadFileBatch.ts"],"sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\nimport { logger } from '../console/logger.js';\nimport { gt } from '../utils/gt.js';\nimport { Settings } from '../types/index.js';\nimport { validateJsonSchema } from '../formats/json/utils.js';\nimport { validateYamlSchema } from '../formats/yaml/utils.js';\nimport { mergeJson } from '../formats/json/mergeJson.js';\nimport { extractJson } from '../formats/json/extractJson.js';\nimport mergeYaml from '../formats/yaml/mergeYaml.js';\nimport { extractYaml } from '../formats/yaml/extractYaml.js';\nimport {\n  resolveMintlifyRefs,\n  shouldResolveRefs,\n} from '../utils/resolveMintlifyRefs.js';\nimport {\n  readLockfile,\n  writeLockfile,\n  findOrCreateEntry,\n} from '../fs/config/downloadedVersions.js';\nimport { recordDownloaded, recordRemerged } from '../state/recentDownloads.js';\nimport { recordWarning } from '../state/translateWarnings.js';\nimport stringify from 'fast-json-stable-stringify';\nimport type { FileStatusTracker } from '../workflows/steps/PollJobsStep.js';\nimport { SUPPORTED_FILE_EXTENSIONS } from '../formats/files/supportedFiles.js';\nimport { hasNonIdentityFileFormatTransformForType } from '../formats/files/transformFormat.js';\nimport { getRelative } from '../fs/findFilepath.js';\n\nfunction sortJsonString(data: string): string {\n  const sortedData = stringify(JSON.parse(data));\n  return JSON.stringify(JSON.parse(sortedData), null, 2);\n}\n\n/**\n * Merges translated content with the current source file for schema-based formats.\n */\nfunction mergeWithSource(\n  translatedContent: string,\n  locale: string,\n  inputPath: string,\n  options: Settings\n): string {\n  if (shouldSkipSourceFormatMerge(inputPath, options)) {\n    return translatedContent;\n  }\n  if (!options.options) return translatedContent;\n\n  const jsonSchema = options.options.jsonSchema\n    ? validateJsonSchema(options.options, inputPath)\n    : null;\n  const yamlSchema =\n    !jsonSchema && options.options.yamlSchema\n      ? validateYamlSchema(options.options, inputPath)\n      : null;\n\n  if (!jsonSchema && !yamlSchema) return translatedContent;\n\n  const sourceContent = fs.readFileSync(inputPath, 'utf8');\n  if (!sourceContent) return translatedContent;\n\n  if (jsonSchema) {\n    // Resolve $ref before merging if configured\n    let resolvedSourceContent = sourceContent;\n    if (shouldResolveRefs(inputPath, options.options)) {\n      try {\n        const json = JSON.parse(sourceContent);\n        const { resolved } = resolveMintlifyRefs(json, inputPath);\n        resolvedSourceContent = JSON.stringify(resolved, null, 2);\n      } catch {\n        // Fall through with original content\n      }\n    }\n    return mergeJson(\n      resolvedSourceContent,\n      inputPath,\n      options.options,\n      [{ translatedContent, targetLocale: locale }],\n      options.defaultLocale,\n      options.locales\n    )[0];\n  } else {\n    return mergeYaml(\n      sourceContent,\n      inputPath,\n      options.options,\n      [{ translatedContent, targetLocale: locale }],\n      options.defaultLocale\n    )[0];\n  }\n}\n\n/**\n * Determines whether a source file should be skipped for schema re-merging.\n * @param inputPath - The path of the source file\n * @param options - The settings for the project\n * @returns True if the source file should be skipped for schema re-merging, false otherwise\n */\nfunction shouldSkipSourceFormatMerge(\n  inputPath: string,\n  options: Settings\n): boolean {\n  for (const fileType of SUPPORTED_FILE_EXTENSIONS) {\n    if (!hasNonIdentityFileFormatTransformForType(options, fileType)) continue;\n\n    const transformedSourcePaths = options.files.resolvedPaths[fileType] || [];\n    if (\n      transformedSourcePaths.some(\n        (sourcePath) => getRelative(sourcePath) === inputPath\n      )\n    ) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\nexport type BatchedFiles = {\n  branchId: string;\n  fileId: string;\n  versionId: string;\n  locale: string;\n  outputPath: string;\n  inputPath: string;\n}[];\n\nexport type DownloadFileBatchResult = {\n  successful: BatchedFiles;\n  failed: BatchedFiles;\n  skipped: BatchedFiles;\n};\n/**\n * Downloads multiple translation files in a single batch request\n * @param files - Array of files to download with their output paths\n * @param maxRetries - Maximum number of retry attempts\n * @param retryDelay - Delay between retries in milliseconds\n * @returns Object containing successful and failed file IDs\n */\nexport async function downloadFileBatch(\n  fileTracker: FileStatusTracker,\n  files: BatchedFiles,\n  options: Settings,\n  forceDownload: boolean = false\n): Promise<DownloadFileBatchResult> {\n  // Local record of what version was last downloaded for each fileName:locale\n  const {\n    data: downloadedVersions,\n    entryMap,\n    originalV1,\n  } = readLockfile(options);\n  let didUpdateDownloadedLock = false;\n\n  // Create a map of requested file keys to the file object\n  const requestedFileMap = new Map(\n    files.map((file) => [\n      `${file.branchId}:${file.fileId}:${file.versionId}:${file.locale}`,\n      file,\n    ])\n  );\n  const result: DownloadFileBatchResult = {\n    successful: [],\n    failed: [],\n    skipped: [],\n  };\n\n  // Create a map of translationId to outputPath for easier lookup\n  const outputPathMap = new Map(\n    files.map((file) => [\n      `${file.branchId}:${file.fileId}:${file.versionId}:${file.locale}`,\n      file.outputPath,\n    ])\n  );\n\n  try {\n    // Download the files\n    const responseData = await gt.downloadFileBatch(\n      files.map((file) => ({\n        fileId: file.fileId,\n        branchId: file.branchId,\n        versionId: file.versionId,\n        locale: file.locale,\n      }))\n    );\n    const downloadedFiles = responseData.files || [];\n\n    // Process each file in the response\n    for (const file of downloadedFiles) {\n      const fileKey = `${file.branchId}:${file.fileId}:${file.versionId}:${file.locale}`;\n      const requestedFile = requestedFileMap.get(fileKey);\n      if (!requestedFile) {\n        continue;\n      }\n      try {\n        const outputPath = outputPathMap.get(fileKey);\n        const fileProperties = fileTracker.completed.get(fileKey);\n\n        if (!outputPath || !fileProperties) {\n          logger.warn(`No input/output path found for file: ${fileKey}`);\n          recordWarning(\n            'failed_download',\n            fileKey,\n            'No input/output path found'\n          );\n          result.failed.push(requestedFile);\n          continue;\n        }\n\n        const {\n          fileId,\n          versionId,\n          locale,\n          branchId,\n          fileName: inputPath,\n        } = fileProperties;\n\n        // Ensure the directory exists\n        const dir = path.dirname(outputPath);\n        if (!fs.existsSync(dir)) {\n          fs.mkdirSync(dir, { recursive: true });\n        }\n        // If a local translation already exists for the same source version, skip overwrite\n        const existingEntry = entryMap.get(fileId);\n        const downloadedTranslation =\n          existingEntry?.versionId === versionId\n            ? existingEntry.translations[locale]\n            : undefined;\n        const fileExists = fs.existsSync(outputPath);\n\n        if (!forceDownload && fileExists && downloadedTranslation) {\n          // For schema-based files, re-merge with current source in case\n          // non-translatable fields changed (skip the API download, not the merge)\n          try {\n            let existingContent = fs.readFileSync(outputPath, 'utf8');\n            // Resolve $ref before extraction if configured\n            if (shouldResolveRefs(outputPath, options.options)) {\n              try {\n                const json = JSON.parse(existingContent);\n                const { resolved } = resolveMintlifyRefs(json, outputPath);\n                existingContent = JSON.stringify(resolved, null, 2);\n              } catch {\n                // Fall through with original content\n              }\n            }\n            const jsonExtracted = options.options?.jsonSchema\n              ? extractJson(\n                  existingContent,\n                  inputPath,\n                  options.options,\n                  locale,\n                  options.defaultLocale\n                )\n              : null;\n            const extracted =\n              jsonExtracted ??\n              (options.options?.yamlSchema\n                ? extractYaml(existingContent, inputPath, options.options)\n                : null);\n            if (extracted) {\n              const remerged = mergeWithSource(\n                extracted,\n                locale,\n                inputPath,\n                options\n              );\n              let remergedData = remerged;\n              if (outputPath.endsWith('.json')) {\n                try {\n                  remergedData = sortJsonString(remergedData);\n                } catch {\n                  // Fall through with unsorted content\n                }\n              }\n              if (remergedData !== existingContent) {\n                await fs.promises.writeFile(outputPath, remergedData);\n              }\n              // Track for postprocessing (e.g. openapi path localization)\n              // even when the API download was skipped\n              recordRemerged(outputPath);\n            }\n          } catch {\n            // If re-merge fails, still count as skipped — not worth failing the download\n          }\n          result.skipped.push(requestedFile);\n          continue;\n        }\n        let data = mergeWithSource(file.data, locale, inputPath, options);\n\n        // Stable sort JSON keys for deterministic output\n        if (file.fileFormat === 'GTJSON' || outputPath.endsWith('.json')) {\n          try {\n            data = sortJsonString(data);\n          } catch (error) {\n            logger.warn(`Failed to sort JSON file: ${file.id}: ` + error);\n          }\n        }\n\n        // Write the file to disk\n        await fs.promises.writeFile(outputPath, data);\n        // Track as downloaded with metadata for downstream postprocessing\n        recordDownloaded(outputPath, {\n          branchId,\n          fileId,\n          versionId,\n          locale,\n          inputPath,\n        });\n\n        result.successful.push(requestedFile);\n        if (fileId && versionId && locale) {\n          const entry = findOrCreateEntry(\n            entryMap,\n            downloadedVersions.entries,\n            fileId,\n            versionId\n          );\n          entry.fileName = inputPath;\n          entry.staged = false;\n          entry.translations[locale] = {\n            updatedAt: new Date().toISOString(),\n            fileName: outputPath,\n          };\n          didUpdateDownloadedLock = true;\n        }\n      } catch (error) {\n        logger.error(`Error saving file ${fileKey}: ` + error);\n        recordWarning(\n          'failed_download',\n          fileKey,\n          `Error saving file: ${error}`\n        );\n        result.failed.push(requestedFile);\n      }\n    }\n\n    // Add any files that weren't in the response to the failed list\n    const downloadedFileKeys = new Set(\n      downloadedFiles.map(\n        (file) =>\n          `${file.branchId}:${file.fileId}:${file.versionId}:${file.locale}`\n      )\n    );\n    for (const [fileKey, requestedFile] of requestedFileMap.entries()) {\n      if (!downloadedFileKeys.has(fileKey)) {\n        result.failed.push(requestedFile);\n      }\n    }\n\n    // Persist any updates to the downloaded map at the end of a successful cycle\n    if (didUpdateDownloadedLock) {\n      writeLockfile(downloadedVersions, originalV1);\n      didUpdateDownloadedLock = false;\n    }\n    return result;\n  } catch (error) {\n    logger.error(\n      `An unexpected error occurred while downloading files: ` + error\n    );\n  }\n\n  // Mark all files as failed if we get here\n  result.failed = [...requestedFileMap.values()];\n  if (didUpdateDownloadedLock) {\n    writeLockfile(downloadedVersions, originalV1);\n  }\n  return result;\n}\n"],"mappings":"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"}

package/dist/api/saveLocalEdits.js

@@ -1,43 +1,39 @@
-import { aggregateFiles } from '../formats/files/aggregateFiles.js';
-import { collectAndSendUserEditDiffs } from './collectUserEditDiffs.js';
-import { gt } from '../utils/gt.js';
-import { BranchStep } from '../workflows/steps/BranchStep.js';
-import { logErrorAndExit } from '../console/logging.js';
-import { logger } from '../console/logger.js';
-import chalk from 'chalk';
-import { runPublishWorkflow } from '../workflows/publish.js';
+import { logger } from "../console/logger.js";
+import { gt } from "../utils/gt.js";
+import { logErrorAndExit } from "../console/logging.js";
+import { branchResolutionError } from "../console/index.js";
+import { BranchStep } from "../workflows/steps/BranchStep.js";
+import { runPublishWorkflow } from "../workflows/publish.js";
+import { collectAndSendUserEditDiffs } from "./collectUserEditDiffs.js";
+import { aggregateFiles } from "../formats/files/aggregateFiles.js";
+import chalk from "chalk";
+//#region src/api/saveLocalEdits.ts
 /**
- * Uploads current source files to obtain file references, then collects and sends
- * diffs for all locales based on last downloaded versions. Does not enqueue translations.
- */
-export async function saveLocalEdits(settings) {
-    if (!settings.files)
-        return;
-    // Collect current files from config
-    const { files, publishMap } = await aggregateFiles(settings);
-    if (!files.length)
-        return;
-    // run branch query to get branch id
-    // Run the branch step
-    const branchStep = new BranchStep(gt, settings);
-    const branchResult = await branchStep.run();
-    await branchStep.wait();
-    if (!branchResult) {
-        return logErrorAndExit('Failed to resolve git branch information.');
-    }
-    const uploads = files.map((file) => ({
-        fileName: file.fileName,
-        fileFormat: file.fileFormat,
-        branchId: branchResult.currentBranch.id,
-        fileId: file.fileId,
-        versionId: file.versionId,
-    }));
-    const spinner = logger.createSpinner('dots');
-    spinner.start('Saving local edits...');
-    const hadDiffs = await collectAndSendUserEditDiffs(uploads, settings);
-    spinner.stop(chalk.green('Local edits saved successfully'));
-    // Publish files to CDN if diffs were detected and publish config exists
-    if (hadDiffs) {
-        await runPublishWorkflow(files, publishMap, branchResult.currentBranch.id, settings);
-    }
+* Uploads current source files to obtain file references, then collects and sends
+* diffs for all locales based on last downloaded versions. Does not enqueue translations.
+*/
+async function saveLocalEdits(settings) {
+	if (!settings.files) return;
+	const { files, publishMap } = await aggregateFiles(settings);
+	if (!files.length) return;
+	const branchStep = new BranchStep(gt, settings);
+	const branchResult = await branchStep.run();
+	await branchStep.wait();
+	if (!branchResult) return logErrorAndExit(branchResolutionError);
+	const uploads = files.map((file) => ({
+		fileName: file.fileName,
+		fileFormat: file.fileFormat,
+		branchId: branchResult.currentBranch.id,
+		fileId: file.fileId,
+		versionId: file.versionId
+	}));
+	const spinner = logger.createSpinner("dots");
+	spinner.start("Saving local edits...");
+	const hadDiffs = await collectAndSendUserEditDiffs(uploads, settings);
+	spinner.stop(chalk.green("Local edits saved successfully"));
+	if (hadDiffs) await runPublishWorkflow(files, publishMap, branchResult.currentBranch.id, settings);
 }
+//#endregion
+export { saveLocalEdits };
+
+//# sourceMappingURL=saveLocalEdits.js.map

package/dist/api/saveLocalEdits.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"saveLocalEdits.js","names":[],"sources":["../../src/api/saveLocalEdits.ts"],"sourcesContent":["import { Settings } from '../types/index.js';\nimport { aggregateFiles } from '../formats/files/aggregateFiles.js';\nimport { collectAndSendUserEditDiffs } from './collectUserEditDiffs.js';\nimport { gt } from '../utils/gt.js';\nimport { BranchStep } from '../workflows/steps/BranchStep.js';\nimport { logErrorAndExit } from '../console/logging.js';\nimport { logger } from '../console/logger.js';\nimport { branchResolutionError } from '../console/index.js';\nimport type { FileReference } from 'generaltranslation/types';\nimport chalk from 'chalk';\nimport { runPublishWorkflow } from '../workflows/publish.js';\n\n/**\n * Uploads current source files to obtain file references, then collects and sends\n * diffs for all locales based on last downloaded versions. Does not enqueue translations.\n */\nexport async function saveLocalEdits(settings: Settings): Promise<void> {\n  if (!settings.files) return;\n\n  // Collect current files from config\n  const { files, publishMap } = await aggregateFiles(settings);\n  if (!files.length) return;\n\n  // run branch query to get branch id\n  // Run the branch step\n  const branchStep = new BranchStep(gt, settings);\n  const branchResult = await branchStep.run();\n  await branchStep.wait();\n  if (!branchResult) {\n    return logErrorAndExit(branchResolutionError);\n  }\n\n  const uploads = files.map((file) => ({\n    fileName: file.fileName,\n    fileFormat: file.fileFormat,\n    branchId: branchResult.currentBranch.id,\n    fileId: file.fileId,\n    versionId: file.versionId,\n  })) satisfies FileReference[];\n\n  const spinner = logger.createSpinner('dots');\n  spinner.start('Saving local edits...');\n\n  const hadDiffs = await collectAndSendUserEditDiffs(uploads, settings);\n  spinner.stop(chalk.green('Local edits saved successfully'));\n\n  // Publish files to CDN if diffs were detected and publish config exists\n  if (hadDiffs) {\n    await runPublishWorkflow(\n      files,\n      publishMap,\n      branchResult.currentBranch.id,\n      settings\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAgBA,eAAsB,eAAe,UAAmC;AACtE,KAAI,CAAC,SAAS,MAAO;CAGrB,MAAM,EAAE,OAAO,eAAe,MAAM,eAAe,SAAS;AAC5D,KAAI,CAAC,MAAM,OAAQ;CAInB,MAAM,aAAa,IAAI,WAAW,IAAI,SAAS;CAC/C,MAAM,eAAe,MAAM,WAAW,KAAK;AAC3C,OAAM,WAAW,MAAM;AACvB,KAAI,CAAC,aACH,QAAO,gBAAgB,sBAAsB;CAG/C,MAAM,UAAU,MAAM,KAAK,UAAU;EACnC,UAAU,KAAK;EACf,YAAY,KAAK;EACjB,UAAU,aAAa,cAAc;EACrC,QAAQ,KAAK;EACb,WAAW,KAAK;EACjB,EAAE;CAEH,MAAM,UAAU,OAAO,cAAc,OAAO;AAC5C,SAAQ,MAAM,wBAAwB;CAEtC,MAAM,WAAW,MAAM,4BAA4B,SAAS,SAAS;AACrE,SAAQ,KAAK,MAAM,MAAM,iCAAiC,CAAC;AAG3D,KAAI,SACF,OAAM,mBACJ,OACA,YACA,aAAa,cAAc,IAC3B,SACD"}

package/dist/bin/bin-entry.js

@@ -1,9 +1,19 @@
-// Entry point for binaries
-import { main } from '../index.js';
-import dotenv from 'dotenv';
-import { program } from 'commander';
-dotenv.config({ path: '.env' });
-dotenv.config({ path: '.env.local', override: true });
-dotenv.config({ path: '.env.production', override: true });
+import { main } from "../index.js";
+import dotenv from "dotenv";
+import { program } from "commander";
+//#region src/bin/bin-entry.ts
+dotenv.config({ path: ".env" });
+dotenv.config({
+	path: ".env.local",
+	override: true
+});
+dotenv.config({
+	path: ".env.production",
+	override: true
+});
 main(program);
 program.parse();
+//#endregion
+export {};
+
+//# sourceMappingURL=bin-entry.js.map

package/dist/bin/bin-entry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin-entry.js","names":[],"sources":["../../src/bin/bin-entry.ts"],"sourcesContent":["// Entry point for binaries\n\nimport { main } from '../index.js';\nimport dotenv from 'dotenv';\nimport { program } from 'commander';\n\ndotenv.config({ path: '.env' });\ndotenv.config({ path: '.env.local', override: true });\ndotenv.config({ path: '.env.production', override: true });\n\nmain(program);\nprogram.parse();\n"],"mappings":";;;;AAMA,OAAO,OAAO,EAAE,MAAM,QAAQ,CAAC;AAC/B,OAAO,OAAO;CAAE,MAAM;CAAc,UAAU;CAAM,CAAC;AACrD,OAAO,OAAO;CAAE,MAAM;CAAmB,UAAU;CAAM,CAAC;AAE1D,KAAK,QAAQ;AACb,QAAQ,OAAO"}