gtx-cli 2.1.5-alpha.2 → 2.1.5-alpha.5

package/dist/formats/files/translate.js

@@ -1,42 +1,38 @@
-import { logError } from '../../console/logging.js';
+import { checkFileTranslations } from '../../api/checkFileTranslations.js';
+import { sendFiles } from '../../api/sendFiles.js';
+import { noSupportedFormatError, noLocalesError, noDefaultLocaleError, noApiKeyError, noProjectIdError, devApiKeyError, } from '../../console/index.js';
+import { logErrorAndExit, createSpinner, logError, logSuccess, } from '../../console/logging.js';
 import { getRelative, readFile } from '../../fs/findFilepath.js';
+import chalk from 'chalk';
+import { downloadFile } from '../../api/downloadFile.js';
+import { downloadFileBatch } from '../../api/downloadFileBatch.js';
 import { SUPPORTED_FILE_EXTENSIONS } from './supportedFiles.js';
 import sanitizeFileContent from '../../utils/sanitizeFileContent.js';
 import { parseJson } from '../json/parseJson.js';
+import { createFileMapping } from './fileMapping.js';
 import parseYaml from '../yaml/parseYaml.js';
-import { determineLibrary } from '../../fs/determineFramework.js';
-export const SUPPORTED_DATA_FORMATS = ['JSX', 'ICU', 'I18NEXT'];
-export async function aggregateFiles(settings) {
-    // Aggregate all files to translate
+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 options - Translation options including API settings
+ * @returns Promise that resolves when translation is complete
+ */
+export async function translateFiles(filePaths, placeholderPaths, transformPaths, dataFormat = 'JSX', options) {
+    // Collect all files to translate
     const allFiles = [];
-    if (!settings.files ||
-        (Object.keys(settings.files.placeholderPaths).length === 1 &&
-            settings.files.placeholderPaths.gt)) {
-        return allFiles;
-    }
-    const { resolvedPaths: filePaths } = settings.files;
+    const additionalOptions = options.options || {};
     // Process JSON files
     if (filePaths.json) {
-        const { library, additionalModules } = determineLibrary();
-        // Determine dataFormat for JSONs
-        let dataFormat;
-        if (library === 'next-intl') {
-            dataFormat = 'ICU';
-        }
-        else if (library === 'i18next') {
-            if (additionalModules.includes('i18next-icu')) {
-                dataFormat = 'ICU';
-            }
-            else {
-                dataFormat = 'I18NEXT';
-            }
-        }
-        else {
-            dataFormat = 'JSX';
+        if (!SUPPORTED_DATA_FORMATS.includes(dataFormat)) {
+            logErrorAndExit(noSupportedFormatError);
         }
         const jsonFiles = filePaths.json.map((filePath) => {
             const content = readFile(filePath);
-            const parsedJson = parseJson(content, filePath, settings.options || {}, settings.defaultLocale);
+            const parsedJson = parseJson(content, filePath, additionalOptions, options.defaultLocale);
             const relativePath = getRelative(filePath);
             return {
                 content: parsedJson,
@@ -49,14 +45,18 @@ export async function aggregateFiles(settings) {
     }
     // 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, settings.options || {});
+            const { content: parsedYaml, fileFormat } = parseYaml(content, filePath, additionalOptions);
             const relativePath = getRelative(filePath);
             return {
                 content: parsedYaml,
                 fileName: relativePath,
                 fileFormat,
+                dataFormat,
             };
         });
         allFiles.push(...yamlFiles);
@@ -73,6 +73,7 @@ export async function aggregateFiles(settings) {
                     content: sanitizedContent,
                     fileName: relativePath,
                     fileFormat: fileType.toUpperCase(),
+                    dataFormat,
                 };
             });
             allFiles.push(...files);
@@ -80,6 +81,117 @@ export async function aggregateFiles(settings) {
     }
     if (allFiles.length === 0) {
         logError('No files to translate were found. Please check your configuration and try again.');
+        return;
+    }
+    if (options.dryRun) {
+        const fileNames = allFiles.map((file) => `- ${file.fileName}`).join('\n');
+        logSuccess(`Dry run: No files were sent to General Translation. Found files:\n${fileNames}`);
+        return;
+    }
+    // Validate required settings are present
+    if (!options.locales) {
+        logErrorAndExit(noLocalesError);
+    }
+    if (!options.defaultLocale) {
+        logErrorAndExit(noDefaultLocaleError);
+    }
+    if (!options.apiKey) {
+        logErrorAndExit(noApiKeyError);
+    }
+    if (options.apiKey.startsWith('gtx-dev-')) {
+        logErrorAndExit(devApiKeyError);
+    }
+    if (!options.projectId) {
+        logErrorAndExit(noProjectIdError);
+    }
+    try {
+        // Send all files in a single API call
+        const response = await sendFiles(allFiles, {
+            ...options,
+            publish: false,
+            wait: true,
+        });
+        const { data, locales, translations } = response;
+        // Create file mapping for all file types
+        const fileMapping = createFileMapping(filePaths, placeholderPaths, transformPaths, locales, options.defaultLocale);
+        // Process any translations that were already completed and returned with the initial response
+        const downloadStatus = await processInitialTranslations(translations, fileMapping, options);
+        // Check for remaining translations
+        await checkFileTranslations(data, locales, 600, (sourcePath, locale) => fileMapping[locale][sourcePath], downloadStatus, // Pass the already downloaded files to avoid duplicate requests
+        options);
+    }
+    catch (error) {
+        logErrorAndExit(`Error translating files: ${error}`);
+    }
+}
+/**
+ * Processes translations that were already completed and returned with the initial API response
+ * @returns Set of downloaded file+locale combinations
+ */
+async function processInitialTranslations(translations = [], fileMapping, options) {
+    const downloadStatus = {
+        downloaded: new Set(),
+        failed: new Set(),
+    };
+    if (!translations || translations.length === 0) {
+        return downloadStatus;
+    }
+    // Filter for ready translations
+    const readyTranslations = translations.filter((translation) => translation.isReady && translation.fileName);
+    if (readyTranslations.length > 0) {
+        const spinner = createSpinner('dots');
+        spinner.start('Downloading translations...');
+        // Prepare batch download data
+        const batchFiles = readyTranslations
+            .map((translation) => {
+            const { locale, fileName, id } = translation;
+            const outputPath = fileMapping[locale][fileName];
+            if (!outputPath) {
+                return null;
+            }
+            return {
+                translationId: id,
+                inputPath: fileName,
+                outputPath,
+                fileLocale: `${fileName}:${locale}`,
+                locale,
+            };
+        })
+            .filter(Boolean);
+        if (batchFiles.length === 0 || batchFiles[0] === null) {
+            return downloadStatus;
+        }
+        // Use batch download if there are multiple files
+        if (batchFiles.length > 1) {
+            const batchResult = await downloadFileBatch(batchFiles.map(({ translationId, outputPath, inputPath, locale }) => ({
+                translationId,
+                outputPath,
+                inputPath,
+                locale,
+            })), options);
+            // Process results
+            batchFiles.forEach((file) => {
+                const { translationId, fileLocale } = file;
+                if (batchResult.successful.includes(translationId)) {
+                    downloadStatus.downloaded.add(fileLocale);
+                }
+                else if (batchResult.failed.includes(translationId)) {
+                    downloadStatus.failed.add(fileLocale);
+                }
+            });
+        }
+        else if (batchFiles.length === 1) {
+            // For a single file, use the original downloadFile method
+            const file = batchFiles[0];
+            const result = await downloadFile(file.translationId, file.outputPath, file.inputPath, file.locale, options);
+            if (result) {
+                downloadStatus.downloaded.add(file.fileLocale);
+            }
+            else {
+                downloadStatus.failed.add(file.fileLocale);
+            }
+        }
+        spinner.stop(chalk.green('Downloaded cached translations'));
     }
-    return allFiles;
+    return downloadStatus;
 }

package/dist/formats/files/upload.js

@@ -1,6 +1,9 @@
 import { noSupportedFormatError, noDefaultLocaleError, noApiKeyError, noProjectIdError, devApiKeyError, } from '../../console/index.js';
-import { logErrorAndExit, logError } from '../../console/logging.js';
+import { logErrorAndExit, createSpinner, logError, } from '../../console/logging.js';
 import { getRelative, readFile } from '../../fs/findFilepath.js';
+import chalk from 'chalk';
+import { downloadFile } from '../../api/downloadFile.js';
+import { downloadFileBatch } from '../../api/downloadFileBatch.js';
 import { SUPPORTED_FILE_EXTENSIONS } from './supportedFiles.js';
 import sanitizeFileContent from '../../utils/sanitizeFileContent.js';
 import { parseJson } from '../json/parseJson.js';
@@ -136,3 +139,74 @@ export async function upload(filePaths, placeholderPaths, transformPaths, dataFo
         logErrorAndExit(`Error uploading files: ${error}`);
     }
 }
+/**
+ * Processes translations that were already completed and returned with the initial API response
+ * @returns Set of downloaded file+locale combinations
+ */
+async function processInitialTranslations(translations = [], fileMapping, options) {
+    const downloadStatus = {
+        downloaded: new Set(),
+        failed: new Set(),
+    };
+    if (!translations || translations.length === 0) {
+        return downloadStatus;
+    }
+    // Filter for ready translations
+    const readyTranslations = translations.filter((translation) => translation.isReady && translation.fileName);
+    if (readyTranslations.length > 0) {
+        const spinner = createSpinner('dots');
+        spinner.start('Downloading translations...');
+        // Prepare batch download data
+        const batchFiles = readyTranslations
+            .map((translation) => {
+            const { locale, fileName, id } = translation;
+            const outputPath = fileMapping[locale][fileName];
+            if (!outputPath) {
+                return null;
+            }
+            return {
+                translationId: id,
+                outputPath,
+                inputPath: fileName,
+                fileLocale: `${fileName}:${locale}`,
+                locale,
+            };
+        })
+            .filter(Boolean);
+        if (batchFiles.length === 0 || batchFiles[0] === null) {
+            return downloadStatus;
+        }
+        // Use batch download if there are multiple files
+        if (batchFiles.length > 1) {
+            const batchResult = await downloadFileBatch(batchFiles.map(({ translationId, outputPath, inputPath, locale }) => ({
+                translationId,
+                outputPath,
+                inputPath,
+                locale,
+            })), options);
+            // Process results
+            batchFiles.forEach((file) => {
+                const { translationId, fileLocale } = file;
+                if (batchResult.successful.includes(translationId)) {
+                    downloadStatus.downloaded.add(fileLocale);
+                }
+                else if (batchResult.failed.includes(translationId)) {
+                    downloadStatus.failed.add(fileLocale);
+                }
+            });
+        }
+        else if (batchFiles.length === 1) {
+            // For a single file, use the original downloadFile method
+            const file = batchFiles[0];
+            const result = await downloadFile(file.translationId, file.outputPath, file.inputPath, file.locale, options);
+            if (result) {
+                downloadStatus.downloaded.add(file.fileLocale);
+            }
+            else {
+                downloadStatus.failed.add(file.fileLocale);
+            }
+        }
+        spinner.stop(chalk.green('Downloaded cached translations'));
+    }
+    return downloadStatus;
+}

package/dist/formats/gt/save.d.ts

@@ -1,9 +1,10 @@
 import { RetrievedTranslations } from 'generaltranslation/types';
 import { ResolvedFiles } from '../../types/index.js';
+import { DataFormat } from '../../types/data.js';
 /**
  * Saves translations to a local directory
  * @param translations - The translations to save
  * @param translationsDir - The directory to save the translations to
  * @param fileType - The file type to save the translations as (file extension)
  */
-export declare function saveTranslations(translations: RetrievedTranslations, placeholderPaths: ResolvedFiles): Promise<void>;
+export declare function saveTranslations(translations: RetrievedTranslations, placeholderPaths: ResolvedFiles, dataFormat: DataFormat): Promise<void>;

package/dist/formats/gt/save.js

@@ -9,7 +9,7 @@ import { resolveLocaleFiles } from '../../fs/config/parseFilesConfig.js';
  * @param translationsDir - The directory to save the translations to
  * @param fileType - The file type to save the translations as (file extension)
  */
-export async function saveTranslations(translations, placeholderPaths) {
+export async function saveTranslations(translations, placeholderPaths, dataFormat) {
     for (const translation of translations) {
         const locale = translation.locale;
         const translationFiles = resolveLocaleFiles(placeholderPaths, locale);
@@ -21,6 +21,9 @@ export async function saveTranslations(translations, placeholderPaths) {
         const translationData = translation.translation;
         // Ensure directory exists
         await fs.promises.mkdir(path.dirname(filepath), { recursive: true });
-        await fs.promises.writeFile(filepath, JSON.stringify(translationData, null, 2));
+        // Handle different file types
+        if (dataFormat === 'JSX') {
+            await fs.promises.writeFile(filepath, JSON.stringify(translationData, null, 2));
+        }
     }
 }

package/dist/fs/config/setupConfig.d.ts

@@ -13,5 +13,4 @@ export declare function createOrUpdateConfig(configFilepath: string, options: {
     files?: FilesOptions;
     framework?: SupportedFrameworks;
     baseUrl?: string;
-    publish?: boolean;
 }): Promise<string>;

package/dist/fs/config/setupConfig.js

@@ -17,7 +17,6 @@ export async function createOrUpdateConfig(configFilepath, options) {
         ...(options.files && { files: options.files }),
         ...(options.framework && { framework: options.framework }),
         ...(options.baseUrl && { baseUrl: options.baseUrl }),
-        ...(options.publish && { publish: options.publish }),
     };
     try {
         // if file exists

package/dist/fs/config/updateConfig.d.ts

@@ -2,9 +2,10 @@
  * Update the config file version id, locales, and projectId (if necessary)
  * @param {Record<string, any>} configObject - The config object to write if the file does not exist.
  */
-export default function updateConfig({ configFilepath, projectId, _versionId, stageTranslations, }: {
+export default function updateConfig({ configFilepath, projectId, _versionId, locales, stageTranslations, }: {
     configFilepath: string;
     projectId?: string;
     _versionId?: string;
+    locales?: string[];
     stageTranslations?: boolean;
 }): Promise<void>;

package/dist/fs/config/updateConfig.js

@@ -5,7 +5,7 @@ import { logError } from '../../console/logging.js';
  * Update the config file version id, locales, and projectId (if necessary)
  * @param {Record<string, any>} configObject - The config object to write if the file does not exist.
  */
-export default async function updateConfig({ configFilepath, projectId, _versionId, stageTranslations, }) {
+export default async function updateConfig({ configFilepath, projectId, _versionId, locales, stageTranslations, }) {
     // Filter out empty string values from the config object
     const newContent = {
         ...(projectId && { projectId }),

package/dist/fs/copyFile.d.ts

@@ -1,7 +1,8 @@
 import { Settings } from '../types/index.js';
+import { TranslateOptions } from '../cli/base.js';
 /**
  * Copy a file to target locale without translation
  *
  * This is a naive approach, does not allow for wild cards
  */
-export default function copyFile(settings: Settings): Promise<void>;
+export default function copyFile(settings: Settings & TranslateOptions): Promise<void>;

package/dist/translation/parse.d.ts

@@ -1,4 +1,4 @@
-import { Updates, TranslateFlags } from '../types/index.js';
+import { Options, GenerateSourceOptions, Updates } from '../types/index.js';
 /**
  * Searches for gt-react or gt-next dictionary files and creates updates for them,
  * as well as inline updates for <T> tags and useGT()/getGT() calls
@@ -8,7 +8,7 @@ import { Updates, TranslateFlags } from '../types/index.js';
  * @param pkg - The package name
  * @returns An object containing the updates and errors
  */
-export declare function createUpdates(options: TranslateFlags, sourceDictionary: string | undefined, pkg: 'gt-react' | 'gt-next', validate: boolean): Promise<{
+export declare function createUpdates(options: Options | GenerateSourceOptions, sourceDictionary: string | undefined, pkg: 'gt-react' | 'gt-next', validate: boolean): Promise<{
     updates: Updates;
     errors: string[];
     warnings: string[];

package/dist/translation/parse.js

@@ -48,10 +48,12 @@ export async function createUpdates(options, sourceDictionary, pkg, validate) {
         }
     }
     // Scan through project for <T> tags
-    const { updates: newUpdates, errors: newErrors, warnings: newWarnings, } = await createInlineUpdates(pkg, validate, options.src);
-    errors = [...errors, ...newErrors];
-    warnings = [...warnings, ...newWarnings];
-    updates = [...updates, ...newUpdates];
+    if (options.inline) {
+        const { updates: newUpdates, errors: newErrors, warnings: newWarnings, } = await createInlineUpdates(pkg, validate, options.src);
+        errors = [...errors, ...newErrors];
+        warnings = [...warnings, ...newWarnings];
+        updates = [...updates, ...newUpdates];
+    }
     // Metadata addition and validation
     const idHashMap = new Map();
     const duplicateIds = new Set();

package/dist/translation/stage.d.ts

@@ -1,2 +1,5 @@
-import { Settings, TranslateFlags, Updates } from '../types/index.js';
-export declare function aggregateReactTranslations(options: TranslateFlags, settings: Settings, library: 'gt-react' | 'gt-next'): Promise<Updates>;
+import { Options, Settings } from '../types/index.js';
+export declare function stageProject(settings: Options & Settings, pkg: 'gt-react' | 'gt-next'): Promise<{
+    versionId: string;
+    locales: string[];
+} | null>;

package/dist/translation/stage.js

@@ -1,11 +1,14 @@
+import { devApiKeyError } from '../console/index.js';
 import { logErrorAndExit } from '../console/logging.js';
 import chalk from 'chalk';
 import findFilepath from '../fs/findFilepath.js';
-import { logWarning, logError } from '../console/logging.js';
+import { logSuccess, logWarning, logError } from '../console/logging.js';
 import { createUpdates } from './parse.js';
-export async function aggregateReactTranslations(options, settings, library) {
-    if (!options.dictionary) {
-        options.dictionary = findFilepath([
+import { noLocalesError, noDefaultLocaleError, noProjectIdError, noApiKeyError, } from '../console/index.js';
+import { sendUpdates } from '../api/sendUpdates.js';
+export async function stageProject(settings, pkg) {
+    if (!settings.dictionary) {
+        settings.dictionary = findFilepath([
             './dictionary.js',
             './src/dictionary.js',
             './dictionary.json',
@@ -14,16 +17,29 @@ export async function aggregateReactTranslations(options, settings, library) {
             './src/dictionary.ts',
         ]);
     }
+    // Separate defaultLocale from locales
+    settings.locales = settings.locales.filter((locale) => locale !== settings.defaultLocale);
+    // validate timeout
+    const timeout = parseInt(settings.timeout);
+    if (isNaN(timeout) || timeout < 0) {
+        logErrorAndExit(`Invalid timeout: ${settings.timeout}. Must be a positive integer.`);
+    }
+    settings.timeout = timeout.toString();
     // ---- CREATING UPDATES ---- //
-    const { updates, errors, warnings } = await createUpdates(options, options.dictionary, library, false);
+    const { updates, errors, warnings } = await createUpdates(settings, settings.dictionary, pkg, false);
     if (warnings.length > 0) {
-        logWarning(chalk.yellow(`CLI tool encountered ${warnings.length} warnings while scanning for translatable content.\n` +
-            warnings
-                .map((warning) => chalk.yellow('• Warning: ') + chalk.white(warning))
-                .join('\n')));
+        if (settings.suppressWarnings) {
+            logWarning(chalk.yellow(`CLI tool encountered ${warnings.length} warnings while scanning for translatable content. ${chalk.gray('To view these warnings, re-run without the --suppress-warnings flag')}`));
+        }
+        else {
+            logWarning(chalk.yellow(`CLI tool encountered ${warnings.length} warnings while scanning for translatable content. ${chalk.gray('To suppress these warnings, re-run with --suppress-warnings')}\n` +
+                warnings
+                    .map((warning) => chalk.yellow('• Warning: ') + chalk.white(warning))
+                    .join('\n')));
+        }
     }
     if (errors.length > 0) {
-        if (options.ignoreErrors) {
+        if (settings.ignoreErrors) {
             logWarning(chalk.yellow(`Warning: CLI tool encountered ${errors.length} syntax errors while scanning for translatable content. These components will not be translated.\n` +
                 errors
                     .map((error) => chalk.yellow('• ') + chalk.white(error) + '\n')
@@ -36,9 +52,35 @@ export async function aggregateReactTranslations(options, settings, library) {
                     .join('')));
         }
     }
+    if (settings.dryRun) {
+        logSuccess('Dry run: No translations were sent to General Translation.');
+        return null;
+    }
     if (updates.length == 0) {
-        logError(chalk.red(`No in-line content or dictionaries were found for ${chalk.green(library)}. Are you sure you're running this command in the right directory?`));
-        return updates;
+        logError(chalk.red(`No in-line content or dictionaries were found for ${chalk.green(pkg)}. Are you sure you're running this command in the right directory?`));
+        return null;
+    }
+    // Send updates to General Translation API
+    if (!settings.locales) {
+        logErrorAndExit(noLocalesError);
+    }
+    if (!settings.defaultLocale) {
+        logErrorAndExit(noDefaultLocaleError);
+    }
+    if (!settings.apiKey) {
+        logErrorAndExit(noApiKeyError);
+    }
+    if (settings.apiKey.startsWith('gtx-dev-')) {
+        logErrorAndExit(devApiKeyError);
+    }
+    if (!settings.projectId) {
+        logErrorAndExit(noProjectIdError);
     }
-    return updates;
+    const updateResponse = await sendUpdates(updates, {
+        ...settings,
+        timeout: settings.timeout,
+        dataFormat: 'JSX',
+    }, pkg);
+    const { versionId, locales } = updateResponse;
+    return { versionId, locales };
 }

package/dist/translation/translate.d.ts

@@ -0,0 +1,2 @@
+import { Options, Settings } from '../types/index.js';
+export declare function translate(settings: Options & Settings, versionId: string): Promise<void>;

package/dist/translation/translate.js

@@ -0,0 +1,18 @@
+import { fetchTranslations } from '../api/fetchTranslations.js';
+import { waitForUpdates } from '../api/waitForUpdates.js';
+import { saveTranslations } from '../formats/gt/save.js';
+import { isUsingLocalTranslations } from '../config/utils.js';
+export async function translate(settings, versionId) {
+    // timeout was validated earlier
+    const startTime = Date.now();
+    const timeout = parseInt(settings.timeout) * 1000;
+    const result = await waitForUpdates(versionId, startTime, timeout);
+    if (!result) {
+        process.exit(1);
+    }
+    const translations = await fetchTranslations(versionId);
+    // Save translations to local directory if files.gt.output is provided
+    if (settings.files && isUsingLocalTranslations(settings)) {
+        await saveTranslations(translations, settings.files.placeholderPaths, 'JSX');
+    }
+}

package/dist/types/index.d.ts

@@ -15,35 +15,13 @@ export type Options = {
     ignoreErrors: boolean;
     suppressWarnings: boolean;
     dryRun: boolean;
-    timeout: number;
+    timeout: string;
     stageTranslations?: boolean;
     experimentalLocalizeStaticUrls?: boolean;
     experimentalHideDefaultLocale?: boolean;
     experimentalFlattenJsonFiles?: boolean;
     experimentalLocalizeStaticImports?: boolean;
 };
-export type TranslateFlags = {
-    config?: string;
-    apiKey?: string;
-    projectId?: string;
-    versionId?: string;
-    jsconfig?: string;
-    dictionary?: string;
-    defaultLocale?: string;
-    locales?: string[];
-    ignoreErrors?: boolean;
-    src?: string[];
-    timeout: number;
-    dryRun: boolean;
-    stageTranslations?: boolean;
-    publish?: boolean;
-    experimentalLocalizeStaticUrls?: boolean;
-    experimentalHideDefaultLocale?: boolean;
-    experimentalFlattenJsonFiles?: boolean;
-    experimentalLocalizeStaticImports?: boolean;
-    excludeStaticUrls?: string[];
-    excludeStaticImports?: string[];
-};
 export type WrapOptions = {
     src?: string[];
     config: string;
@@ -102,11 +80,10 @@ export type FilesOptions = {
 };
 export type Settings = {
     config: string;
-    configDirectory: string;
     baseUrl: string;
     dashboardUrl: string;
-    apiKey?: string;
-    projectId?: string;
+    apiKey: string;
+    projectId: string;
     defaultLocale: string;
     locales: string[];
     files: {
@@ -115,7 +92,6 @@ export type Settings = {
         transformPaths: TransformFiles;
     } | undefined;
     stageTranslations: boolean;
-    publish: boolean;
     _versionId?: string;
     version?: string;
     description?: string;
@@ -141,6 +117,7 @@ export type AdditionalOptions = {
     experimentalLocalizeStaticUrls?: boolean;
     experimentalHideDefaultLocale?: boolean;
     experimentalFlattenJsonFiles?: boolean;
+    baseDomain?: string;
 };
 export type JsonSchema = {
     preset?: 'mintlify';

package/dist/utils/flattenJsonFiles.d.ts

@@ -1,2 +1,2 @@
-import { Settings } from '../types/index.js';
-export default function flattenJsonFiles(settings: Settings): Promise<void>;
+import { Settings, Options } from '../types/index.js';
+export default function flattenJsonFiles(settings: Omit<Settings & Options, 'ignoreErrors' | 'suppressWarnings' | 'timeout'>): Promise<void>;

package/dist/utils/localizeStaticImports.d.ts

@@ -1,4 +1,4 @@
-import { Settings } from '../types/index.js';
+import { Options, Settings } from '../types/index.js';
 /**
  * Localizes static imports in content files.
  * Currently only supported for md and mdx files. (/docs/ -> /[locale]/docs/)
@@ -12,4 +12,4 @@ import { Settings } from '../types/index.js';
  * - Support more file types
  * - Support more complex paths
  */
-export default function localizeStaticImports(settings: Settings): Promise<void>;
+export default function localizeStaticImports(settings: Omit<Settings & Options, 'ignoreErrors' | 'suppressWarnings' | 'timeout'>): Promise<void>;

package/dist/utils/localizeStaticUrls.d.ts

@@ -1,4 +1,4 @@
-import { Settings } from '../types/index.js';
+import { Options, Settings } from '../types/index.js';
 /**
  * Localizes static urls in content files.
  * Currently only supported for md and mdx files. (/docs/ -> /[locale]/docs/)
@@ -12,4 +12,8 @@ import { Settings } from '../types/index.js';
  * - Support more file types
  * - Support more complex paths
  */
-export default function localizeStaticUrls(settings: Settings): Promise<void>;
+export default function localizeStaticUrls(settings: Omit<Settings & Options, 'ignoreErrors' | 'suppressWarnings' | 'timeout'>, targetLocales?: string[]): Promise<void>;
+/**
+ * Main URL transformation function that delegates to specific scenarios
+ */
+export declare function transformUrlPath(originalUrl: string, patternHead: string, targetLocale: string, defaultLocale: string, hideDefaultLocale: boolean): string | null;