gt 2.14.35 → 2.14.37

package/dist/cli/commands/translate.js

@@ -1,117 +1,80 @@
-import { runDownloadWorkflow, } from '../../workflows/download.js';
-import { createFileMapping } from '../../formats/files/fileMapping.js';
-import copyFile from '../../fs/copyFile.js';
-import flattenJsonFiles from '../../utils/flattenJsonFiles.js';
-import localizeStaticUrls from '../../utils/localizeStaticUrls.js';
-import localizeRelativeAssets from '../../utils/localizeRelativeAssets.js';
-import processAnchorIds from '../../utils/processAnchorIds.js';
-import processOpenApi from '../../utils/processOpenApi.js';
-import localizeStaticImports from '../../utils/localizeStaticImports.js';
-import { getDownloadedMeta } from '../../state/recentDownloads.js';
-import { persistPostProcessHashes } from '../../utils/persistPostprocessHashes.js';
-import { runPublishWorkflow } from '../../workflows/publish.js';
-import { SUPPORTED_FILE_EXTENSIONS } from '../../formats/files/supportedFiles.js';
-import { hasNonIdentityFileFormatTransformForType } from '../../formats/files/transformFormat.js';
-import { getRelative } from '../../fs/findFilepath.js';
-// Downloads translations that were completed
-export async function handleTranslate(options, settings, fileVersionData, jobData, branchData, publishMap) {
-    if (fileVersionData) {
-        const { resolvedPaths, placeholderPaths, transformPaths, transformFormats, } = settings.files;
-        const fileMapping = createFileMapping(resolvedPaths, placeholderPaths, transformPaths, transformFormats, settings.locales, settings.defaultLocale);
-        // Check for remaining translations
-        await runDownloadWorkflow({
-            fileVersionData: fileVersionData,
-            jobData: jobData,
-            branchData: branchData,
-            locales: settings.locales,
-            timeoutDuration: options.timeout,
-            resolveOutputPath: (sourcePath, locale) => fileMapping[locale]?.[sourcePath] ?? null,
-            options: settings,
-            forceRetranslation: options.force,
-            forceDownload: options.forceDownload || options.force, // if force is true should also force download
-        });
-        // Publish/unpublish files after translations are downloaded
-        if (publishMap && branchData?.currentBranch.id) {
-            const files = Object.entries(fileVersionData).map(([fileId, data]) => ({
-                fileId,
-                versionId: data.versionId,
-                fileName: data.fileName,
-            }));
-            await runPublishWorkflow(files, publishMap, branchData.currentBranch.id, settings);
-        }
-    }
+import { getRelative } from "../../fs/findFilepath.js";
+import { SUPPORTED_FILE_EXTENSIONS } from "../../formats/files/supportedFiles.js";
+import { hasNonIdentityFileFormatTransformForType } from "../../formats/files/transformFormat.js";
+import { createFileMapping } from "../../formats/files/fileMapping.js";
+import { runPublishWorkflow } from "../../workflows/publish.js";
+import { getDownloadedMeta } from "../../state/recentDownloads.js";
+import { runDownloadWorkflow } from "../../workflows/download.js";
+import copyFile from "../../fs/copyFile.js";
+import flattenJsonFiles from "../../utils/flattenJsonFiles.js";
+import localizeStaticUrls from "../../utils/localizeStaticUrls.js";
+import localizeRelativeAssets from "../../utils/localizeRelativeAssets.js";
+import processAnchorIds from "../../utils/processAnchorIds.js";
+import processOpenApi from "../../utils/processOpenApi.js";
+import localizeStaticImports from "../../utils/localizeStaticImports.js";
+import { persistPostProcessHashes } from "../../utils/persistPostprocessHashes.js";
+//#region src/cli/commands/translate.ts
+async function handleTranslate(options, settings, fileVersionData, jobData, branchData, publishMap) {
+	if (fileVersionData) {
+		const { resolvedPaths, placeholderPaths, transformPaths, transformFormats } = settings.files;
+		const fileMapping = createFileMapping(resolvedPaths, placeholderPaths, transformPaths, transformFormats, settings.locales, settings.defaultLocale);
+		await runDownloadWorkflow({
+			fileVersionData,
+			jobData,
+			branchData,
+			locales: settings.locales,
+			timeoutDuration: options.timeout,
+			resolveOutputPath: (sourcePath, locale) => fileMapping[locale]?.[sourcePath] ?? null,
+			options: settings,
+			forceRetranslation: options.force,
+			forceDownload: options.forceDownload || options.force
+		});
+		if (publishMap && branchData?.currentBranch.id) await runPublishWorkflow(Object.entries(fileVersionData).map(([fileId, data]) => ({
+			fileId,
+			versionId: data.versionId,
+			fileName: data.fileName
+		})), publishMap, branchData.currentBranch.id, settings);
+	}
 }
-export async function postProcessTranslations(settings, includeFiles) {
-    const postProcessIncludes = filterPostProcessIncludesForFormatTransforms(settings, includeFiles);
-    if (includeFiles && postProcessIncludes?.size === 0)
-        return;
-    // Mintlify OpenAPI localization (spec routing + validation)
-    await processOpenApi(settings, postProcessIncludes);
-    // Localize static urls (/docs -> /[locale]/docs) and preserve anchor IDs for non-default locales
-    // Default locale is processed earlier in the flow in base.ts
-    if (settings.options?.experimentalLocalizeStaticUrls) {
-        const nonDefaultLocales = settings.locales.filter((locale) => locale !== settings.defaultLocale);
-        if (nonDefaultLocales.length > 0) {
-            await localizeStaticUrls(settings, nonDefaultLocales, postProcessIncludes);
-        }
-    }
-    // Rewrite relative asset URLs in translated md/mdx files
-    if (settings.options?.experimentalLocalizeRelativeAssets) {
-        const nonDefaultLocales = settings.locales.filter((locale) => locale !== settings.defaultLocale);
-        if (nonDefaultLocales.length > 0) {
-            await localizeRelativeAssets(settings, nonDefaultLocales, postProcessIncludes);
-        }
-    }
-    const shouldProcessAnchorIds = settings.options?.experimentalLocalizeStaticUrls ||
-        settings.options?.experimentalAddHeaderAnchorIds;
-    // Add explicit anchor IDs to translated MDX/MD files to preserve navigation
-    // Uses inline {#id} format by default, or div wrapping if experimentalAddHeaderAnchorIds is 'mintlify'
-    if (shouldProcessAnchorIds) {
-        await processAnchorIds(settings, postProcessIncludes);
-    }
-    // Localize static imports (import Snippet from /snippets/file.mdx -> import Snippet from /snippets/[locale]/file.mdx)
-    if (settings.options?.experimentalLocalizeStaticImports) {
-        await localizeStaticImports(settings, postProcessIncludes);
-    }
-    // Flatten json files into a single file
-    if (settings.options?.experimentalFlattenJsonFiles) {
-        await flattenJsonFiles(settings, postProcessIncludes);
-    }
-    // Copy files to the target locale
-    if (settings.options?.copyFiles) {
-        await copyFile(settings);
-    }
-    // Record postprocessed content hashes for newly downloaded files
-    persistPostProcessHashes(settings, postProcessIncludes, getDownloadedMeta());
+async function postProcessTranslations(settings, includeFiles) {
+	const postProcessIncludes = filterPostProcessIncludesForFormatTransforms(settings, includeFiles);
+	if (includeFiles && postProcessIncludes?.size === 0) return;
+	await processOpenApi(settings, postProcessIncludes);
+	if (settings.options?.experimentalLocalizeStaticUrls) {
+		const nonDefaultLocales = settings.locales.filter((locale) => locale !== settings.defaultLocale);
+		if (nonDefaultLocales.length > 0) await localizeStaticUrls(settings, nonDefaultLocales, postProcessIncludes);
+	}
+	if (settings.options?.experimentalLocalizeRelativeAssets) {
+		const nonDefaultLocales = settings.locales.filter((locale) => locale !== settings.defaultLocale);
+		if (nonDefaultLocales.length > 0) await localizeRelativeAssets(settings, nonDefaultLocales, postProcessIncludes);
+	}
+	if (settings.options?.experimentalLocalizeStaticUrls || settings.options?.experimentalAddHeaderAnchorIds) await processAnchorIds(settings, postProcessIncludes);
+	if (settings.options?.experimentalLocalizeStaticImports) await localizeStaticImports(settings, postProcessIncludes);
+	if (settings.options?.experimentalFlattenJsonFiles) await flattenJsonFiles(settings, postProcessIncludes);
+	if (settings.options?.copyFiles) await copyFile(settings);
+	persistPostProcessHashes(settings, postProcessIncludes, getDownloadedMeta());
 }
 /**
- * Exclude only outputs whose source file was translated into a different format.
- * @param settings - The settings for the project
- * @param includeFiles - The files to include in the post-processing
- * @returns The files to exclude in the post-processing
- */
+* Exclude only outputs whose source file was translated into a different format.
+* @param settings - The settings for the project
+* @param includeFiles - The files to include in the post-processing
+* @returns The files to exclude in the post-processing
+*/
 function filterPostProcessIncludesForFormatTransforms(settings, includeFiles) {
-    if (!includeFiles)
-        return includeFiles;
-    const transformedSourcePaths = new Set();
-    for (const fileType of SUPPORTED_FILE_EXTENSIONS) {
-        if (!hasNonIdentityFileFormatTransformForType(settings, fileType))
-            continue;
-        for (const sourcePath of settings.files.resolvedPaths[fileType] || []) {
-            transformedSourcePaths.add(getRelative(sourcePath));
-        }
-    }
-    if (transformedSourcePaths.size === 0)
-        return includeFiles;
-    const { resolvedPaths, placeholderPaths, transformPaths, transformFormats } = settings.files;
-    const fileMapping = createFileMapping(resolvedPaths, placeholderPaths, transformPaths, transformFormats, settings.locales, settings.defaultLocale);
-    const transformedOutputPaths = new Set();
-    for (const localeMapping of Object.values(fileMapping)) {
-        for (const [sourcePath, outputPath] of Object.entries(localeMapping)) {
-            if (transformedSourcePaths.has(sourcePath)) {
-                transformedOutputPaths.add(outputPath);
-            }
-        }
-    }
-    return new Set([...includeFiles].filter((filePath) => !transformedOutputPaths.has(filePath)));
+	if (!includeFiles) return includeFiles;
+	const transformedSourcePaths = /* @__PURE__ */ new Set();
+	for (const fileType of SUPPORTED_FILE_EXTENSIONS) {
+		if (!hasNonIdentityFileFormatTransformForType(settings, fileType)) continue;
+		for (const sourcePath of settings.files.resolvedPaths[fileType] || []) transformedSourcePaths.add(getRelative(sourcePath));
+	}
+	if (transformedSourcePaths.size === 0) return includeFiles;
+	const { resolvedPaths, placeholderPaths, transformPaths, transformFormats } = settings.files;
+	const fileMapping = createFileMapping(resolvedPaths, placeholderPaths, transformPaths, transformFormats, settings.locales, settings.defaultLocale);
+	const transformedOutputPaths = /* @__PURE__ */ new Set();
+	for (const localeMapping of Object.values(fileMapping)) for (const [sourcePath, outputPath] of Object.entries(localeMapping)) if (transformedSourcePaths.has(sourcePath)) transformedOutputPaths.add(outputPath);
+	return new Set([...includeFiles].filter((filePath) => !transformedOutputPaths.has(filePath)));
 }
+//#endregion
+export { handleTranslate, postProcessTranslations };
+
+//# sourceMappingURL=translate.js.map

package/dist/cli/commands/translate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"translate.js","names":[],"sources":["../../../src/cli/commands/translate.ts"],"sourcesContent":["import { EnqueueFilesResult } from 'generaltranslation/types';\nimport { TranslateFlags } from '../../types/index.js';\nimport { Settings } from '../../types/index.js';\nimport {\n  FileTranslationData,\n  runDownloadWorkflow,\n} from '../../workflows/download.js';\nimport { createFileMapping } from '../../formats/files/fileMapping.js';\nimport copyFile from '../../fs/copyFile.js';\nimport flattenJsonFiles from '../../utils/flattenJsonFiles.js';\nimport localizeStaticUrls from '../../utils/localizeStaticUrls.js';\nimport localizeRelativeAssets from '../../utils/localizeRelativeAssets.js';\nimport processAnchorIds from '../../utils/processAnchorIds.js';\nimport processOpenApi from '../../utils/processOpenApi.js';\nimport localizeStaticImports from '../../utils/localizeStaticImports.js';\nimport { BranchData } from '../../types/branch.js';\nimport { getDownloadedMeta } from '../../state/recentDownloads.js';\nimport { persistPostProcessHashes } from '../../utils/persistPostprocessHashes.js';\nimport { runPublishWorkflow } from '../../workflows/publish.js';\nimport { SUPPORTED_FILE_EXTENSIONS } from '../../formats/files/supportedFiles.js';\nimport { hasNonIdentityFileFormatTransformForType } from '../../formats/files/transformFormat.js';\nimport { getRelative } from '../../fs/findFilepath.js';\n\n// Downloads translations that were completed\nexport async function handleTranslate(\n  options: TranslateFlags,\n  settings: Settings,\n  fileVersionData: FileTranslationData | undefined,\n  jobData: EnqueueFilesResult | undefined,\n  branchData: BranchData | undefined,\n  publishMap?: Map<string, boolean>\n) {\n  if (fileVersionData) {\n    const {\n      resolvedPaths,\n      placeholderPaths,\n      transformPaths,\n      transformFormats,\n    } = settings.files;\n\n    const fileMapping = createFileMapping(\n      resolvedPaths,\n      placeholderPaths,\n      transformPaths,\n      transformFormats,\n      settings.locales,\n      settings.defaultLocale\n    );\n    // Check for remaining translations\n    await runDownloadWorkflow({\n      fileVersionData: fileVersionData,\n      jobData: jobData,\n      branchData: branchData,\n      locales: settings.locales,\n      timeoutDuration: options.timeout,\n      resolveOutputPath: (sourcePath, locale) =>\n        fileMapping[locale]?.[sourcePath] ?? null,\n      options: settings,\n      forceRetranslation: options.force,\n      forceDownload: options.forceDownload || options.force, // if force is true should also force download\n    });\n\n    // Publish/unpublish files after translations are downloaded\n    if (publishMap && branchData?.currentBranch.id) {\n      const files = Object.entries(fileVersionData).map(([fileId, data]) => ({\n        fileId,\n        versionId: data.versionId,\n        fileName: data.fileName,\n      }));\n      await runPublishWorkflow(\n        files,\n        publishMap,\n        branchData.currentBranch.id,\n        settings\n      );\n    }\n  }\n}\n\nexport async function postProcessTranslations(\n  settings: Settings,\n  includeFiles?: Set<string>\n) {\n  const postProcessIncludes = filterPostProcessIncludesForFormatTransforms(\n    settings,\n    includeFiles\n  );\n  if (includeFiles && postProcessIncludes?.size === 0) return;\n\n  // Mintlify OpenAPI localization (spec routing + validation)\n  await processOpenApi(settings, postProcessIncludes);\n\n  // Localize static urls (/docs -> /[locale]/docs) and preserve anchor IDs for non-default locales\n  // Default locale is processed earlier in the flow in base.ts\n  if (settings.options?.experimentalLocalizeStaticUrls) {\n    const nonDefaultLocales = settings.locales.filter(\n      (locale) => locale !== settings.defaultLocale\n    );\n    if (nonDefaultLocales.length > 0) {\n      await localizeStaticUrls(\n        settings,\n        nonDefaultLocales,\n        postProcessIncludes\n      );\n    }\n  }\n\n  // Rewrite relative asset URLs in translated md/mdx files\n  if (settings.options?.experimentalLocalizeRelativeAssets) {\n    const nonDefaultLocales = settings.locales.filter(\n      (locale) => locale !== settings.defaultLocale\n    );\n    if (nonDefaultLocales.length > 0) {\n      await localizeRelativeAssets(\n        settings,\n        nonDefaultLocales,\n        postProcessIncludes\n      );\n    }\n  }\n\n  const shouldProcessAnchorIds =\n    settings.options?.experimentalLocalizeStaticUrls ||\n    settings.options?.experimentalAddHeaderAnchorIds;\n\n  // Add explicit anchor IDs to translated MDX/MD files to preserve navigation\n  // Uses inline {#id} format by default, or div wrapping if experimentalAddHeaderAnchorIds is 'mintlify'\n  if (shouldProcessAnchorIds) {\n    await processAnchorIds(settings, postProcessIncludes);\n  }\n\n  // Localize static imports (import Snippet from /snippets/file.mdx -> import Snippet from /snippets/[locale]/file.mdx)\n  if (settings.options?.experimentalLocalizeStaticImports) {\n    await localizeStaticImports(settings, postProcessIncludes);\n  }\n\n  // Flatten json files into a single file\n  if (settings.options?.experimentalFlattenJsonFiles) {\n    await flattenJsonFiles(settings, postProcessIncludes);\n  }\n\n  // Copy files to the target locale\n  if (settings.options?.copyFiles) {\n    await copyFile(settings);\n  }\n\n  // Record postprocessed content hashes for newly downloaded files\n  persistPostProcessHashes(settings, postProcessIncludes, getDownloadedMeta());\n}\n\n/**\n * Exclude only outputs whose source file was translated into a different format.\n * @param settings - The settings for the project\n * @param includeFiles - The files to include in the post-processing\n * @returns The files to exclude in the post-processing\n */\nfunction filterPostProcessIncludesForFormatTransforms(\n  settings: Settings,\n  includeFiles?: Set<string>\n): Set<string> | undefined {\n  if (!includeFiles) return includeFiles;\n\n  const transformedSourcePaths = new Set<string>();\n  for (const fileType of SUPPORTED_FILE_EXTENSIONS) {\n    if (!hasNonIdentityFileFormatTransformForType(settings, fileType)) continue;\n\n    for (const sourcePath of settings.files.resolvedPaths[fileType] || []) {\n      transformedSourcePaths.add(getRelative(sourcePath));\n    }\n  }\n  if (transformedSourcePaths.size === 0) return includeFiles;\n\n  const { resolvedPaths, placeholderPaths, transformPaths, transformFormats } =\n    settings.files;\n  const fileMapping = createFileMapping(\n    resolvedPaths,\n    placeholderPaths,\n    transformPaths,\n    transformFormats,\n    settings.locales,\n    settings.defaultLocale\n  );\n\n  const transformedOutputPaths = new Set<string>();\n  for (const localeMapping of Object.values(fileMapping)) {\n    for (const [sourcePath, outputPath] of Object.entries(localeMapping)) {\n      if (transformedSourcePaths.has(sourcePath)) {\n        transformedOutputPaths.add(outputPath);\n      }\n    }\n  }\n\n  return new Set(\n    [...includeFiles].filter(\n      (filePath) => !transformedOutputPaths.has(filePath)\n    )\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAwBA,eAAsB,gBACpB,SACA,UACA,iBACA,SACA,YACA,YACA;AACA,KAAI,iBAAiB;EACnB,MAAM,EACJ,eACA,kBACA,gBACA,qBACE,SAAS;EAEb,MAAM,cAAc,kBAClB,eACA,kBACA,gBACA,kBACA,SAAS,SACT,SAAS,cACV;AAED,QAAM,oBAAoB;GACP;GACR;GACG;GACZ,SAAS,SAAS;GAClB,iBAAiB,QAAQ;GACzB,oBAAoB,YAAY,WAC9B,YAAY,UAAU,eAAe;GACvC,SAAS;GACT,oBAAoB,QAAQ;GAC5B,eAAe,QAAQ,iBAAiB,QAAQ;GACjD,CAAC;AAGF,MAAI,cAAc,YAAY,cAAc,GAM1C,OAAM,mBALQ,OAAO,QAAQ,gBAAgB,CAAC,KAAK,CAAC,QAAQ,WAAW;GACrE;GACA,WAAW,KAAK;GAChB,UAAU,KAAK;GAChB,EAEM,EACL,YACA,WAAW,cAAc,IACzB,SACD;;;AAKP,eAAsB,wBACpB,UACA,cACA;CACA,MAAM,sBAAsB,6CAC1B,UACA,aACD;AACD,KAAI,gBAAgB,qBAAqB,SAAS,EAAG;AAGrD,OAAM,eAAe,UAAU,oBAAoB;AAInD,KAAI,SAAS,SAAS,gCAAgC;EACpD,MAAM,oBAAoB,SAAS,QAAQ,QACxC,WAAW,WAAW,SAAS,cACjC;AACD,MAAI,kBAAkB,SAAS,EAC7B,OAAM,mBACJ,UACA,mBACA,oBACD;;AAKL,KAAI,SAAS,SAAS,oCAAoC;EACxD,MAAM,oBAAoB,SAAS,QAAQ,QACxC,WAAW,WAAW,SAAS,cACjC;AACD,MAAI,kBAAkB,SAAS,EAC7B,OAAM,uBACJ,UACA,mBACA,oBACD;;AAUL,KALE,SAAS,SAAS,kCAClB,SAAS,SAAS,+BAKlB,OAAM,iBAAiB,UAAU,oBAAoB;AAIvD,KAAI,SAAS,SAAS,kCACpB,OAAM,sBAAsB,UAAU,oBAAoB;AAI5D,KAAI,SAAS,SAAS,6BACpB,OAAM,iBAAiB,UAAU,oBAAoB;AAIvD,KAAI,SAAS,SAAS,UACpB,OAAM,SAAS,SAAS;AAI1B,0BAAyB,UAAU,qBAAqB,mBAAmB,CAAC;;;;;;;;AAS9E,SAAS,6CACP,UACA,cACyB;AACzB,KAAI,CAAC,aAAc,QAAO;CAE1B,MAAM,yCAAyB,IAAI,KAAa;AAChD,MAAK,MAAM,YAAY,2BAA2B;AAChD,MAAI,CAAC,yCAAyC,UAAU,SAAS,CAAE;AAEnE,OAAK,MAAM,cAAc,SAAS,MAAM,cAAc,aAAa,EAAE,CACnE,wBAAuB,IAAI,YAAY,WAAW,CAAC;;AAGvD,KAAI,uBAAuB,SAAS,EAAG,QAAO;CAE9C,MAAM,EAAE,eAAe,kBAAkB,gBAAgB,qBACvD,SAAS;CACX,MAAM,cAAc,kBAClB,eACA,kBACA,gBACA,kBACA,SAAS,SACT,SAAS,cACV;CAED,MAAM,yCAAyB,IAAI,KAAa;AAChD,MAAK,MAAM,iBAAiB,OAAO,OAAO,YAAY,CACpD,MAAK,MAAM,CAAC,YAAY,eAAe,OAAO,QAAQ,cAAc,CAClE,KAAI,uBAAuB,IAAI,WAAW,CACxC,wBAAuB,IAAI,WAAW;AAK5C,QAAO,IAAI,IACT,CAAC,GAAG,aAAa,CAAC,QACf,aAAa,CAAC,uBAAuB,IAAI,SAAS,CACpD,CACF"}

package/dist/cli/commands/upload.js

@@ -1,215 +1,187 @@
-import { noSupportedFormatError, noDefaultLocaleError, } from '../../console/index.js';
-import { exitSync, logErrorAndExit } from '../../console/logging.js';
-import { logger } from '../../console/logger.js';
-import { getRelative, readFile } from '../../fs/findFilepath.js';
-import { SUPPORTED_FILE_EXTENSIONS } from '../../formats/files/supportedFiles.js';
-import sanitizeFileContent from '../../utils/sanitizeFileContent.js';
-import { parseJson } from '../../formats/json/parseJson.js';
-import { extractJson } from '../../formats/json/extractJson.js';
-import { validateJsonSchema } from '../../formats/json/utils.js';
-import { resolveMintlifyRefs, shouldResolveRefs, } from '../../utils/resolveMintlifyRefs.js';
-import { runUploadFilesWorkflow } from '../../workflows/upload.js';
-import { existsSync, readFileSync } from 'node:fs';
-import { createFileMapping } from '../../formats/files/fileMapping.js';
-import parseYaml from '../../formats/yaml/parseYaml.js';
-import { hashStringSync } from '../../utils/hash.js';
-import { hasValidCredentials } from './utils/validation.js';
-import { buildPublishMap } from '../../utils/resolvePublish.js';
-import { runPublishWorkflow } from '../../workflows/publish.js';
-import { getTransformFormatProperty } from '../../formats/files/transformFormat.js';
-const SUPPORTED_DATA_FORMATS = ['JSX', 'ICU', 'I18NEXT'];
+import { logger } from "../../console/logger.js";
+import { hashStringSync } from "../../utils/hash.js";
+import { exitSync, logErrorAndExit } from "../../console/logging.js";
+import { getRelative, readFile } from "../../fs/findFilepath.js";
+import { noDefaultLocaleError, noSupportedFormatError } from "../../console/index.js";
+import { SUPPORTED_FILE_EXTENSIONS } from "../../formats/files/supportedFiles.js";
+import { getTransformFormatProperty } from "../../formats/files/transformFormat.js";
+import sanitizeFileContent from "../../utils/sanitizeFileContent.js";
+import { validateJsonSchema } from "../../formats/json/utils.js";
+import { parseJson } from "../../formats/json/parseJson.js";
+import { extractJson } from "../../formats/json/extractJson.js";
+import { resolveMintlifyRefs, shouldResolveRefs } from "../../utils/resolveMintlifyRefs.js";
+import { runUploadFilesWorkflow } from "../../workflows/upload.js";
+import { createFileMapping } from "../../formats/files/fileMapping.js";
+import parseYaml from "../../formats/yaml/parseYaml.js";
+import { hasValidCredentials } from "./utils/validation.js";
+import { buildPublishMap } from "../../utils/resolvePublish.js";
+import { runPublishWorkflow } from "../../workflows/publish.js";
+import { existsSync, readFileSync } from "node:fs";
+//#region src/cli/commands/upload.ts
+const SUPPORTED_DATA_FORMATS = [
+	"JSX",
+	"ICU",
+	"I18NEXT"
+];
 /**
- * Sends multiple files to the API for translation
- * @param filePaths - Resolved file paths for different file types
- * @param placeholderPaths - Placeholder paths for translated files
- * @param transformPaths - Transform paths for file naming
- * @param dataFormat - Format of the data within the files
- * @param settings - Translation options including API settings
- * @returns Promise that resolves when translation is complete
- */
-export async function upload(filePaths, placeholderPaths, transformPaths, dataFormat = 'JSX', settings) {
-    // Collect all files to translate
-    const allFiles = [];
-    const additionalOptions = settings.options || {};
-    const compositeJsonFiles = new Map();
-    // Process JSON files
-    if (filePaths.json) {
-        if (!SUPPORTED_DATA_FORMATS.includes(dataFormat)) {
-            logErrorAndExit(noSupportedFormatError);
-        }
-        const jsonFiles = filePaths.json.map((filePath) => {
-            const content = readFile(filePath);
-            // Resolve $ref before parsing if configured
-            let contentForParsing = content;
-            if (shouldResolveRefs(filePath, additionalOptions)) {
-                try {
-                    const json = JSON.parse(content);
-                    const { resolved } = resolveMintlifyRefs(json, filePath);
-                    contentForParsing = JSON.stringify(resolved, null, 2);
-                }
-                catch {
-                    // JSON parse errors are handled below by parseJson
-                }
-            }
-            const parsedJson = parseJson(contentForParsing, filePath, additionalOptions, settings.defaultLocale);
-            const relativePath = getRelative(filePath);
-            const jsonSchema = validateJsonSchema(additionalOptions, filePath);
-            if (jsonSchema?.composite) {
-                compositeJsonFiles.set(relativePath, { filePath, content });
-            }
-            return {
-                content: parsedJson,
-                fileName: relativePath,
-                fileFormat: 'JSON',
-                ...getTransformFormatProperty(settings, 'json'),
-                dataFormat,
-                locale: settings.defaultLocale,
-                fileId: hashStringSync(relativePath),
-                versionId: hashStringSync(parsedJson),
-            };
-        });
-        allFiles.push(...jsonFiles);
-    }
-    // Process YAML files
-    if (filePaths.yaml) {
-        if (!SUPPORTED_DATA_FORMATS.includes(dataFormat)) {
-            logErrorAndExit(noSupportedFormatError);
-        }
-        const yamlFiles = filePaths.yaml.map((filePath) => {
-            const content = readFile(filePath);
-            const { content: parsedYaml, fileFormat } = parseYaml(content, filePath, additionalOptions);
-            const relativePath = getRelative(filePath);
-            return {
-                content: parsedYaml,
-                fileName: relativePath,
-                fileFormat,
-                ...getTransformFormatProperty(settings, 'yaml'),
-                dataFormat,
-                locale: settings.defaultLocale,
-                fileId: hashStringSync(relativePath),
-                versionId: hashStringSync(parsedYaml),
-            };
-        });
-        allFiles.push(...yamlFiles);
-    }
-    // Process Twilio Content JSON files
-    if (filePaths.twilioContentJson) {
-        const twilioContentJsonFiles = filePaths.twilioContentJson.map((filePath) => {
-            const content = readFile(filePath);
-            const parsedJson = parseJson(content, filePath, additionalOptions, settings.defaultLocale);
-            const relativePath = getRelative(filePath);
-            return {
-                content: parsedJson,
-                fileName: relativePath,
-                fileFormat: 'TWILIO_CONTENT_JSON',
-                ...getTransformFormatProperty(settings, 'twilioContentJson'),
-                dataFormat: 'STRING',
-                locale: settings.defaultLocale,
-                fileId: hashStringSync(relativePath),
-                versionId: hashStringSync(parsedJson),
-            };
-        });
-        allFiles.push(...twilioContentJsonFiles);
-    }
-    for (const fileType of SUPPORTED_FILE_EXTENSIONS) {
-        if (fileType === 'json' ||
-            fileType === 'yaml' ||
-            fileType === 'twilioContentJson')
-            continue;
-        if (filePaths[fileType]) {
-            const files = filePaths[fileType].map((filePath) => {
-                const content = readFile(filePath);
-                const sanitizedContent = sanitizeFileContent(content);
-                const relativePath = getRelative(filePath);
-                return {
-                    content: sanitizedContent,
-                    fileName: relativePath,
-                    fileFormat: fileType.toUpperCase(),
-                    ...getTransformFormatProperty(settings, fileType),
-                    dataFormat,
-                    locale: settings.defaultLocale,
-                    fileId: hashStringSync(relativePath),
-                    versionId: hashStringSync(sanitizedContent),
-                };
-            });
-            allFiles.push(...files);
-        }
-    }
-    if (allFiles.length === 0) {
-        logger.error('No files to upload were found. Check your configuration and try again.');
-        return;
-    }
-    if (!settings.defaultLocale) {
-        return logErrorAndExit(noDefaultLocaleError);
-    }
-    if (!hasValidCredentials(settings))
-        return exitSync(1);
-    const locales = settings.locales || [];
-    // Create file mapping for all file types
-    const fileMapping = createFileMapping(filePaths, placeholderPaths, transformPaths, settings.files?.transformFormats || {}, locales, settings.defaultLocale);
-    // construct object
-    const uploadData = allFiles.map((file) => {
-        const sourceFile = {
-            content: file.content,
-            fileName: file.fileName,
-            fileFormat: file.fileFormat,
-            transformFormat: file.transformFormat,
-            dataFormat: file.dataFormat,
-            locale: file.locale,
-            fileId: file.fileId,
-            versionId: file.versionId,
-        };
-        const translations = [];
-        const compositeInfo = compositeJsonFiles.get(file.fileName);
-        for (const locale of locales) {
-            if (compositeInfo) {
-                // Composite JSON: extract translations from the same source file
-                const extracted = extractJson(compositeInfo.content, compositeInfo.filePath, additionalOptions, locale, settings.defaultLocale);
-                if (extracted) {
-                    translations.push({
-                        content: extracted,
-                        fileName: file.fileName,
-                        fileFormat: file.transformFormat ?? file.fileFormat,
-                        dataFormat: file.dataFormat,
-                        locale,
-                        fileId: file.fileId,
-                        versionId: file.versionId,
-                    });
-                }
-            }
-            else {
-                // Non-composite: look for separate translation files
-                const translatedFileName = fileMapping[locale]?.[file.fileName];
-                if (translatedFileName && existsSync(translatedFileName)) {
-                    const translatedContent = readFileSync(translatedFileName, 'utf8');
-                    translations.push({
-                        content: translatedContent,
-                        fileName: translatedFileName,
-                        fileFormat: file.transformFormat ?? file.fileFormat,
-                        dataFormat: file.dataFormat,
-                        locale,
-                        fileId: file.fileId,
-                        versionId: file.versionId,
-                    });
-                }
-            }
-        }
-        return {
-            source: sourceFile,
-            translations,
-        };
-    });
-    try {
-        // Send all files in a single API call
-        const { branchData } = await runUploadFilesWorkflow({
-            files: uploadData,
-            options: settings,
-        });
-        // Publish files to CDN if publish config exists
-        const publishMap = buildPublishMap(filePaths, settings);
-        await runPublishWorkflow(allFiles, publishMap, branchData.currentBranch.id, settings);
-    }
-    catch (error) {
-        logErrorAndExit(`Error uploading files: ${error}`);
-    }
+* Sends multiple files to the API for translation
+* @param filePaths - Resolved file paths for different file types
+* @param placeholderPaths - Placeholder paths for translated files
+* @param transformPaths - Transform paths for file naming
+* @param dataFormat - Format of the data within the files
+* @param settings - Translation options including API settings
+* @returns Promise that resolves when translation is complete
+*/
+async function upload(filePaths, placeholderPaths, transformPaths, dataFormat = "JSX", settings) {
+	const allFiles = [];
+	const additionalOptions = settings.options || {};
+	const compositeJsonFiles = /* @__PURE__ */ new Map();
+	if (filePaths.json) {
+		if (!SUPPORTED_DATA_FORMATS.includes(dataFormat)) logErrorAndExit(noSupportedFormatError);
+		const jsonFiles = filePaths.json.map((filePath) => {
+			const content = readFile(filePath);
+			let contentForParsing = content;
+			if (shouldResolveRefs(filePath, additionalOptions)) try {
+				const { resolved } = resolveMintlifyRefs(JSON.parse(content), filePath);
+				contentForParsing = JSON.stringify(resolved, null, 2);
+			} catch {}
+			const parsedJson = parseJson(contentForParsing, filePath, additionalOptions, settings.defaultLocale);
+			const relativePath = getRelative(filePath);
+			if (validateJsonSchema(additionalOptions, filePath)?.composite) compositeJsonFiles.set(relativePath, {
+				filePath,
+				content
+			});
+			return {
+				content: parsedJson,
+				fileName: relativePath,
+				fileFormat: "JSON",
+				...getTransformFormatProperty(settings, "json"),
+				dataFormat,
+				locale: settings.defaultLocale,
+				fileId: hashStringSync(relativePath),
+				versionId: hashStringSync(parsedJson)
+			};
+		});
+		allFiles.push(...jsonFiles);
+	}
+	if (filePaths.yaml) {
+		if (!SUPPORTED_DATA_FORMATS.includes(dataFormat)) logErrorAndExit(noSupportedFormatError);
+		const yamlFiles = filePaths.yaml.map((filePath) => {
+			const { content: parsedYaml, fileFormat } = parseYaml(readFile(filePath), filePath, additionalOptions);
+			const relativePath = getRelative(filePath);
+			return {
+				content: parsedYaml,
+				fileName: relativePath,
+				fileFormat,
+				...getTransformFormatProperty(settings, "yaml"),
+				dataFormat,
+				locale: settings.defaultLocale,
+				fileId: hashStringSync(relativePath),
+				versionId: hashStringSync(parsedYaml)
+			};
+		});
+		allFiles.push(...yamlFiles);
+	}
+	if (filePaths.twilioContentJson) {
+		const twilioContentJsonFiles = filePaths.twilioContentJson.map((filePath) => {
+			const parsedJson = parseJson(readFile(filePath), filePath, additionalOptions, settings.defaultLocale);
+			const relativePath = getRelative(filePath);
+			return {
+				content: parsedJson,
+				fileName: relativePath,
+				fileFormat: "TWILIO_CONTENT_JSON",
+				...getTransformFormatProperty(settings, "twilioContentJson"),
+				dataFormat: "STRING",
+				locale: settings.defaultLocale,
+				fileId: hashStringSync(relativePath),
+				versionId: hashStringSync(parsedJson)
+			};
+		});
+		allFiles.push(...twilioContentJsonFiles);
+	}
+	for (const fileType of SUPPORTED_FILE_EXTENSIONS) {
+		if (fileType === "json" || fileType === "yaml" || fileType === "twilioContentJson") continue;
+		if (filePaths[fileType]) {
+			const files = filePaths[fileType].map((filePath) => {
+				const sanitizedContent = sanitizeFileContent(readFile(filePath));
+				const relativePath = getRelative(filePath);
+				return {
+					content: sanitizedContent,
+					fileName: relativePath,
+					fileFormat: fileType.toUpperCase(),
+					...getTransformFormatProperty(settings, fileType),
+					dataFormat,
+					locale: settings.defaultLocale,
+					fileId: hashStringSync(relativePath),
+					versionId: hashStringSync(sanitizedContent)
+				};
+			});
+			allFiles.push(...files);
+		}
+	}
+	if (allFiles.length === 0) {
+		logger.error("No files to upload were found. Check your configuration and try again.");
+		return;
+	}
+	if (!settings.defaultLocale) return logErrorAndExit(noDefaultLocaleError);
+	if (!hasValidCredentials(settings)) return exitSync(1);
+	const locales = settings.locales || [];
+	const fileMapping = createFileMapping(filePaths, placeholderPaths, transformPaths, settings.files?.transformFormats || {}, locales, settings.defaultLocale);
+	const uploadData = allFiles.map((file) => {
+		const sourceFile = {
+			content: file.content,
+			fileName: file.fileName,
+			fileFormat: file.fileFormat,
+			transformFormat: file.transformFormat,
+			dataFormat: file.dataFormat,
+			locale: file.locale,
+			fileId: file.fileId,
+			versionId: file.versionId
+		};
+		const translations = [];
+		const compositeInfo = compositeJsonFiles.get(file.fileName);
+		for (const locale of locales) if (compositeInfo) {
+			const extracted = extractJson(compositeInfo.content, compositeInfo.filePath, additionalOptions, locale, settings.defaultLocale);
+			if (extracted) translations.push({
+				content: extracted,
+				fileName: file.fileName,
+				fileFormat: file.transformFormat ?? file.fileFormat,
+				dataFormat: file.dataFormat,
+				locale,
+				fileId: file.fileId,
+				versionId: file.versionId
+			});
+		} else {
+			const translatedFileName = fileMapping[locale]?.[file.fileName];
+			if (translatedFileName && existsSync(translatedFileName)) {
+				const translatedContent = readFileSync(translatedFileName, "utf8");
+				translations.push({
+					content: translatedContent,
+					fileName: translatedFileName,
+					fileFormat: file.transformFormat ?? file.fileFormat,
+					dataFormat: file.dataFormat,
+					locale,
+					fileId: file.fileId,
+					versionId: file.versionId
+				});
+			}
+		}
+		return {
+			source: sourceFile,
+			translations
+		};
+	});
+	try {
+		const { branchData } = await runUploadFilesWorkflow({
+			files: uploadData,
+			options: settings
+		});
+		await runPublishWorkflow(allFiles, buildPublishMap(filePaths, settings), branchData.currentBranch.id, settings);
+	} catch (error) {
+		logErrorAndExit(`Error uploading files: ${error}`);
+	}
 }
+//#endregion
+export { upload };
+
+//# sourceMappingURL=upload.js.map