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

package/dist/utils/localizeStaticUrls.js

@@ -7,6 +7,7 @@ import remarkMdx from 'remark-mdx';
 import remarkFrontmatter from 'remark-frontmatter';
 import remarkStringify from 'remark-stringify';
 import { visit } from 'unist-util-visit';
+import { logMessage } from '../console/logging.js';
 const { isMatch } = micromatch;
 /**
  * Localizes static urls in content files.
@@ -21,19 +22,25 @@ const { isMatch } = micromatch;
  * - Support more file types
  * - Support more complex paths
  */
-export default async function localizeStaticUrls(settings) {
+export default async function localizeStaticUrls(settings, targetLocales // Optional filter for specific locales
+) {
     if (!settings.files ||
         (Object.keys(settings.files.placeholderPaths).length === 1 &&
             settings.files.placeholderPaths.gt)) {
         return;
     }
     const { resolvedPaths: sourceFiles } = settings.files;
-    const fileMapping = createFileMapping(sourceFiles, settings.files.placeholderPaths, settings.files.transformPaths, settings.locales, settings.defaultLocale);
+    // Use filtered locales if provided, otherwise use all locales
+    const locales = targetLocales || settings.locales;
+    const fileMapping = createFileMapping(sourceFiles, settings.files.placeholderPaths, settings.files.transformPaths, settings.locales, // Always use all locales for mapping, filter later
+    settings.defaultLocale);
     // Process all file types at once with a single call
     const processPromises = [];
     // First, process default locale files (from source files)
     // This is needed because they might not be in the fileMapping if they're not being translated
-    if (!fileMapping[settings.defaultLocale]) {
+    // Only process default locale if it's in the target locales filter
+    if (!fileMapping[settings.defaultLocale] &&
+        locales.includes(settings.defaultLocale)) {
         const defaultLocaleFiles = [];
         // Collect all .md and .mdx files from sourceFiles
         if (sourceFiles.md) {
@@ -48,7 +55,7 @@ export default async function localizeStaticUrls(settings) {
                 const fileContent = await fs.promises.readFile(filePath, 'utf8');
                 // Localize the file using default locale
                 const localizedFile = localizeStaticUrlsForFile(fileContent, settings.defaultLocale, settings.defaultLocale, // Process as default locale
-                settings.options?.experimentalHideDefaultLocale || false, settings.options?.docsUrlPattern, settings.options?.excludeStaticUrls);
+                settings.experimentalHideDefaultLocale || false, settings.options?.docsUrlPattern, settings.options?.excludeStaticUrls, settings.options?.baseDomain);
                 // Write the localized file back to the same path
                 await fs.promises.writeFile(filePath, localizedFile);
             }));
@@ -56,7 +63,9 @@ export default async function localizeStaticUrls(settings) {
         }
     }
     // Then process all other locales from fileMapping
-    const mappingPromises = Object.entries(fileMapping).map(async ([locale, filesMap]) => {
+    const mappingPromises = Object.entries(fileMapping)
+        .filter(([locale, filesMap]) => locales.includes(locale)) // Filter by target locales
+        .map(async ([locale, filesMap]) => {
         // Get all files that are md or mdx
         const targetFiles = Object.values(filesMap).filter((path) => path.endsWith('.md') || path.endsWith('.mdx'));
         // Replace the placeholder path with the target path
@@ -64,7 +73,7 @@ export default async function localizeStaticUrls(settings) {
             // Get file content
             const fileContent = await fs.promises.readFile(filePath, 'utf8');
             // Localize the file (handles both URLs and hrefs in single AST pass)
-            const localizedFile = localizeStaticUrlsForFile(fileContent, settings.defaultLocale, locale, settings.options?.experimentalHideDefaultLocale || false, settings.options?.docsUrlPattern, settings.options?.excludeStaticUrls);
+            const localizedFile = localizeStaticUrlsForFile(fileContent, settings.defaultLocale, locale, settings.experimentalHideDefaultLocale || false, settings.options?.docsUrlPattern, settings.options?.excludeStaticUrls, settings.options?.baseDomain);
             // Write the localized file to the target path
             await fs.promises.writeFile(filePath, localizedFile);
         }));
@@ -75,21 +84,28 @@ export default async function localizeStaticUrls(settings) {
 /**
  * Determines if a URL should be processed based on pattern matching
  */
-function shouldProcessUrl(originalUrl, patternHead, targetLocale, defaultLocale) {
-    // Skip absolute URLs (http://, https://, //, etc.)
-    if (originalUrl.includes(':')) {
-        return false;
-    }
+function shouldProcessUrl(originalUrl, patternHead, targetLocale, defaultLocale, baseDomain) {
     const patternWithoutSlash = patternHead.replace(/\/$/, '');
+    // Handle absolute URLs with baseDomain
+    let urlToCheck = originalUrl;
+    if (baseDomain && originalUrl.startsWith(baseDomain)) {
+        urlToCheck = originalUrl.substring(baseDomain.length);
+    }
     if (targetLocale === defaultLocale) {
         // For default locale processing, check if URL contains the pattern
-        return originalUrl.includes(patternWithoutSlash);
+        return urlToCheck.includes(patternWithoutSlash);
     }
     else {
         // For non-default locales, check if URL starts with pattern
-        return originalUrl.startsWith(patternWithoutSlash);
+        return urlToCheck.startsWith(patternWithoutSlash);
     }
 }
+/**
+ * Determines if a URL should be processed based on the base domain
+ */
+function shouldProcessAbsoluteUrl(originalUrl, baseDomain) {
+    return originalUrl.startsWith(baseDomain);
+}
 /**
  * Checks if a URL should be excluded based on exclusion patterns
  */
@@ -98,102 +114,79 @@ function isUrlExcluded(originalUrl, exclude, defaultLocale) {
     return excludePatterns.some((pattern) => isMatch(originalUrl, pattern));
 }
 /**
- * Transforms URL for default locale processing
- */
-function transformDefaultLocaleUrl(originalUrl, patternHead, defaultLocale, hideDefaultLocale) {
-    if (hideDefaultLocale) {
-        // Remove locale from URLs that have it: '/docs/en/file' -> '/docs/file'
-        if (originalUrl.includes(`/${defaultLocale}/`)) {
-            return originalUrl.replace(`/${defaultLocale}/`, '/');
-        }
-        else if (originalUrl.endsWith(`/${defaultLocale}`)) {
-            return originalUrl.replace(`/${defaultLocale}`, '');
-        }
-        return null; // URL doesn't have default locale
-    }
-    else {
-        // Add locale to URLs that don't have it: '/docs/file' -> '/docs/en/file'
-        if (originalUrl.includes(`/${defaultLocale}/`) ||
-            originalUrl.endsWith(`/${defaultLocale}`)) {
-            return null; // Already has default locale
-        }
-        if (originalUrl.startsWith(patternHead)) {
-            const pathAfterHead = originalUrl.slice(patternHead.length);
-            if (pathAfterHead) {
-                return `${patternHead}${defaultLocale}/${pathAfterHead}`;
-            }
-            else {
-                return `${patternHead.replace(/\/$/, '')}/${defaultLocale}`;
-            }
-        }
-        return null; // URL doesn't match pattern
-    }
-}
-/**
- * Transforms URL for non-default locale processing with hideDefaultLocale=true
+ * Main URL transformation function that delegates to specific scenarios
  */
-function transformNonDefaultLocaleUrlWithHidden(originalUrl, patternHead, targetLocale, defaultLocale) {
-    // Check if already localized
-    if (originalUrl.startsWith(`${patternHead}${targetLocale}/`) ||
-        originalUrl === `${patternHead}${targetLocale}`) {
+export function transformUrlPath(originalUrl, patternHead, targetLocale, defaultLocale, hideDefaultLocale) {
+    const originalPathArray = originalUrl
+        .split('/')
+        .filter((path) => path !== '');
+    const patternHeadArray = patternHead.split('/').filter((path) => path !== '');
+    // check if the pattern head matches the original path
+    if (!checkIfPathMatchesPattern(originalPathArray, patternHeadArray)) {
         return null;
     }
-    // Replace default locale with target locale
-    const expectedPathWithDefaultLocale = `${patternHead}${defaultLocale}`;
-    if (originalUrl.startsWith(`${expectedPathWithDefaultLocale}/`) ||
-        originalUrl === expectedPathWithDefaultLocale) {
-        return originalUrl.replace(`${patternHead}${defaultLocale}`, `${patternHead}${targetLocale}`);
-    }
-    // Handle exact pattern match
-    if (originalUrl === patternHead.replace(/\/$/, '')) {
-        return `${patternHead.replace(/\/$/, '')}/${targetLocale}`;
+    if (patternHeadArray.length > originalPathArray.length) {
+        return null; // Pattern is longer than the URL path
     }
-    // Add target locale to URL without any locale
-    const pathAfterHead = originalUrl.slice(originalUrl.startsWith(patternHead) ? patternHead.length : 0);
-    return pathAfterHead
-        ? `${patternHead}${targetLocale}/${pathAfterHead}`
-        : `${patternHead}${targetLocale}`;
-}
-/**
- * Transforms URL for non-default locale processing with hideDefaultLocale=false
- */
-function transformNonDefaultLocaleUrl(originalUrl, patternHead, targetLocale, defaultLocale) {
-    const expectedPathWithLocale = `${patternHead}${defaultLocale}`;
-    if (originalUrl.startsWith(`${expectedPathWithLocale}/`) ||
-        originalUrl === expectedPathWithLocale) {
-        // Replace existing default locale with target locale
-        return originalUrl.replace(`${patternHead}${defaultLocale}`, `${patternHead}${targetLocale}`);
-    }
-    else if (originalUrl.startsWith(patternHead)) {
-        // Add target locale to URL that doesn't have any locale
-        const pathAfterHead = originalUrl.slice(patternHead.length);
-        if (pathAfterHead) {
-            return `${patternHead}${targetLocale}/${pathAfterHead}`;
+    let result = null;
+    if (targetLocale === defaultLocale) {
+        if (hideDefaultLocale) {
+            // check if default locale is already present
+            if (originalPathArray?.[patternHeadArray.length] !== defaultLocale) {
+                return null;
+            }
+            // remove default locale
+            const newPathArray = [
+                ...originalPathArray.slice(0, patternHeadArray.length),
+                ...originalPathArray.slice(patternHeadArray.length + 1),
+            ];
+            result = newPathArray.join('/');
         }
         else {
-            return `${patternHead.replace(/\/$/, '')}/${targetLocale}`;
+            // check if default locale is already present
+            if (originalPathArray?.[patternHeadArray.length] === defaultLocale) {
+                return null;
+            }
+            // insert default locale
+            const newPathArray = [
+                ...originalPathArray.slice(0, patternHeadArray.length),
+                defaultLocale,
+                ...originalPathArray.slice(patternHeadArray.length),
+            ];
+            result = newPathArray.join('/');
         }
     }
-    return null; // URL doesn't match pattern
-}
-/**
- * Main URL transformation function that delegates to specific scenarios
- */
-function transformUrlPath(originalUrl, patternHead, targetLocale, defaultLocale, hideDefaultLocale) {
-    if (targetLocale === defaultLocale) {
-        return transformDefaultLocaleUrl(originalUrl, patternHead, defaultLocale, hideDefaultLocale);
-    }
     else if (hideDefaultLocale) {
-        return transformNonDefaultLocaleUrlWithHidden(originalUrl, patternHead, targetLocale, defaultLocale);
+        const newPathArray = [
+            ...originalPathArray.slice(0, patternHeadArray.length),
+            targetLocale,
+            ...originalPathArray.slice(patternHeadArray.length),
+        ];
+        result = newPathArray.join('/');
     }
     else {
-        return transformNonDefaultLocaleUrl(originalUrl, patternHead, targetLocale, defaultLocale);
+        // check default locale
+        if (originalPathArray?.[patternHeadArray.length] !== defaultLocale) {
+            return null;
+        }
+        // replace default locale with target locale
+        const newPathArray = [...originalPathArray];
+        newPathArray[patternHeadArray.length] = targetLocale;
+        result = newPathArray.join('/');
+    }
+    // check for leading and trailing slashes
+    if (originalUrl.startsWith('/')) {
+        result = '/' + result;
+    }
+    if (originalUrl.endsWith('/')) {
+        result = result + '/';
     }
+    return result;
 }
 /**
  * AST-based transformation for MDX files using remark-mdx
  */
-function transformMdxUrls(mdxContent, defaultLocale, targetLocale, hideDefaultLocale, pattern = '/[locale]', exclude = []) {
+function transformMdxUrls(mdxContent, defaultLocale, targetLocale, hideDefaultLocale, pattern = '/[locale]', exclude = [], baseDomain) {
     const transformedUrls = [];
     if (!pattern.startsWith('/')) {
         pattern = '/' + pattern;
@@ -246,7 +239,21 @@ function transformMdxUrls(mdxContent, defaultLocale, targetLocale, hideDefaultLo
     // Helper function to transform URL based on pattern
     const transformUrl = (originalUrl, linkType) => {
         // Check if URL should be processed
-        if (!shouldProcessUrl(originalUrl, patternHead, targetLocale, defaultLocale)) {
+        if (!shouldProcessUrl(originalUrl, patternHead, targetLocale, defaultLocale, baseDomain)) {
+            return null;
+        }
+        // Skip absolute URLs (http://, https://, //, etc.)
+        if (baseDomain && shouldProcessAbsoluteUrl(originalUrl, baseDomain)) {
+            // Get everything after the base domain
+            logMessage(`originalUrl: ${originalUrl}`);
+            logMessage(`baseDomain: ${baseDomain}`);
+            const afterDomain = originalUrl.substring(baseDomain.length);
+            logMessage(`afterDomain: ${afterDomain}`);
+            const transformedPath = transformUrlPath(afterDomain, patternHead, targetLocale, defaultLocale, hideDefaultLocale);
+            return transformedPath ? baseDomain + transformedPath : null;
+        }
+        // Exclude colon-prefixed URLs (http://, https://, //, etc.)
+        if (originalUrl.split('?')[0].includes(':')) {
             return null;
         }
         // Transform the URL based on locale and configuration
@@ -381,8 +388,24 @@ function transformMdxUrls(mdxContent, defaultLocale, targetLocale, hideDefaultLo
 }
 // AST-based transformation for MDX files using remark
 function localizeStaticUrlsForFile(file, defaultLocale, targetLocale, hideDefaultLocale, pattern = '/[locale]', // eg /docs/[locale] or /[locale]
-exclude = []) {
+exclude = [], baseDomain) {
     // Use AST-based transformation for MDX files
-    const result = transformMdxUrls(file, defaultLocale, targetLocale, hideDefaultLocale, pattern, exclude);
+    const result = transformMdxUrls(file, defaultLocale, targetLocale, hideDefaultLocale, pattern, exclude, baseDomain || '');
     return result.content;
 }
+function cleanPath(path) {
+    let cleanedPath = path.startsWith('/') ? path.slice(1) : path;
+    cleanedPath = cleanedPath.endsWith('/')
+        ? cleanedPath.slice(0, -1)
+        : cleanedPath;
+    return cleanedPath;
+}
+function checkIfPathMatchesPattern(originalUrlArray, patternHeadArray) {
+    // check if the pattern head matches the original path
+    for (let i = 0; i < patternHeadArray.length; i++) {
+        if (patternHeadArray[i] !== originalUrlArray?.[i]) {
+            return false;
+        }
+    }
+    return true;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtx-cli",
-  "version": "2.1.5-alpha.2",
+  "version": "2.1.5-alpha.5",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [
@@ -87,7 +87,7 @@
     "esbuild": "^0.25.4",
     "fast-glob": "^3.3.3",
     "form-data": "^4.0.4",
-    "generaltranslation": "^7.4.1-alpha.1",
+    "generaltranslation": "^7.4.0",
     "json-pointer": "^0.6.2",
     "jsonpath-plus": "^10.3.0",
     "jsonpointer": "^5.0.1",

package/dist/cli/commands/stage.d.ts

@@ -1,5 +0,0 @@
-import { Settings, SupportedLibraries, TranslateFlags } from '../../types/index.js';
-import { SendFilesResult } from '../../api/sendFiles.js';
-export declare const TEMPLATE_FILE_NAME = "__INTERNAL_GT_TEMPLATE_NAME__";
-export declare const TEMPLATE_FILE_ID: string;
-export declare function handleStage(options: TranslateFlags, settings: Settings, library: SupportedLibraries, stage: boolean): Promise<SendFilesResult | undefined>;

package/dist/cli/commands/stage.js

@@ -1,100 +0,0 @@
-import { logErrorAndExit, logSuccess } from '../../console/logging.js';
-import { noLocalesError, noDefaultLocaleError, noApiKeyError, noProjectIdError, devApiKeyError, invalidConfigurationError, } from '../../console/index.js';
-import { aggregateFiles } from '../../formats/files/translate.js';
-import { aggregateReactTranslations } from '../../translation/stage.js';
-import { sendFiles } from '../../api/sendFiles.js';
-import { updateVersions } from '../../fs/config/updateVersions.js';
-import updateConfig from '../../fs/config/updateConfig.js';
-import { hashStringSync } from '../../utils/hash.js';
-export const TEMPLATE_FILE_NAME = '__INTERNAL_GT_TEMPLATE_NAME__';
-export const TEMPLATE_FILE_ID = hashStringSync(TEMPLATE_FILE_NAME);
-export async function handleStage(options, settings, library, stage) {
-    // Validate required settings are present if not in dry run
-    if (!options.dryRun) {
-        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);
-        }
-    }
-    // Aggregate files
-    const allFiles = await aggregateFiles(settings);
-    // Parse for React components
-    let reactComponents = 0;
-    if (library === 'gt-react' || library === 'gt-next') {
-        const updates = await aggregateReactTranslations(options, settings, library);
-        if (updates.length > 0) {
-            if (!options.dryRun &&
-                !settings.publish &&
-                !settings.files?.placeholderPaths.gt) {
-                logErrorAndExit(invalidConfigurationError);
-            }
-            reactComponents = updates.length;
-            // Convert updates to a file object
-            const fileData = {};
-            const fileMetadata = {};
-            // Convert updates to the proper data format
-            for (const update of updates) {
-                const { source, metadata, dataFormat } = update;
-                metadata.dataFormat = dataFormat; // add the data format to the metadata
-                const { hash, id } = metadata;
-                if (id) {
-                    fileData[id] = source;
-                    fileMetadata[id] = metadata;
-                }
-                else {
-                    fileData[hash] = source;
-                    fileMetadata[hash] = metadata;
-                }
-            }
-            allFiles.push({
-                fileName: TEMPLATE_FILE_NAME,
-                content: JSON.stringify(fileData),
-                fileFormat: 'GTJSON',
-                formatMetadata: fileMetadata,
-            });
-        }
-    }
-    // Dry run
-    if (options.dryRun) {
-        const fileNames = allFiles
-            .map((file) => {
-            if (file.fileName === TEMPLATE_FILE_NAME) {
-                return `- <React Elements> (${reactComponents})`;
-            }
-            return `- ${file.fileName}`;
-        })
-            .join('\n');
-        logSuccess(`Dry run: No files were sent to General Translation. Found files:\n${fileNames}`);
-        return undefined;
-    }
-    // Send translations to General Translation
-    let filesTranslationResponse;
-    if (allFiles.length > 0) {
-        filesTranslationResponse = await sendFiles(allFiles, options, settings);
-        if (stage) {
-            await updateVersions({
-                configDirectory: settings.configDirectory,
-                versionData: filesTranslationResponse.data,
-            });
-        }
-        const { versionId } = filesTranslationResponse.data[TEMPLATE_FILE_ID];
-        if (versionId) {
-            await updateConfig({
-                configFilepath: settings.config,
-                _versionId: versionId,
-            });
-        }
-    }
-    return filesTranslationResponse;
-}

package/dist/cli/commands/translate.d.ts

@@ -1,6 +0,0 @@
-import { SendFilesResult } from '../../api/sendFiles.js';
-import { TranslateFlags } from '../../types/index.js';
-import { Settings } from '../../types/index.js';
-export declare function handleTranslate(options: TranslateFlags, settings: Settings, filesTranslationResponse: SendFilesResult | undefined): Promise<void>;
-export declare function handleDownload(options: TranslateFlags, settings: Settings): Promise<void>;
-export declare function postProcessTranslations(settings: Settings): Promise<void>;

package/dist/cli/commands/translate.js

@@ -1,54 +0,0 @@
-import { checkFileTranslations } from '../../api/checkFileTranslations.js';
-import { createFileMapping } from '../../formats/files/fileMapping.js';
-import { logError } from '../../console/logging.js';
-import { getStagedVersions } from '../../fs/config/updateVersions.js';
-import copyFile from '../../fs/copyFile.js';
-import localizeStaticImports from '../../utils/localizeStaticImports.js';
-import flattenJsonFiles from '../../utils/flattenJsonFiles.js';
-import localizeStaticUrls from '../../utils/localizeStaticUrls.js';
-import { noFilesError, noVersionIdError } from '../../console/index.js';
-// Downloads translations that were completed
-export async function handleTranslate(options, settings, filesTranslationResponse) {
-    if (filesTranslationResponse && settings.files) {
-        const { resolvedPaths, placeholderPaths, transformPaths } = settings.files;
-        const fileMapping = createFileMapping(resolvedPaths, placeholderPaths, transformPaths, settings.locales, settings.defaultLocale);
-        const { data } = filesTranslationResponse;
-        // Check for remaining translations
-        await checkFileTranslations(data, settings.locales, options.timeout, (sourcePath, locale) => fileMapping[locale][sourcePath] ?? null, settings);
-    }
-}
-// Downloads translations that were originally staged
-export async function handleDownload(options, settings) {
-    if (!settings._versionId) {
-        logError(noVersionIdError);
-        process.exit(1);
-    }
-    if (!settings.files) {
-        logError(noFilesError);
-        process.exit(1);
-    }
-    // Files
-    const { resolvedPaths, placeholderPaths, transformPaths } = settings.files;
-    const fileMapping = createFileMapping(resolvedPaths, placeholderPaths, transformPaths, settings.locales, settings.defaultLocale);
-    const stagedVersionData = await getStagedVersions(settings.configDirectory);
-    // Check for remaining translations
-    await checkFileTranslations(stagedVersionData, settings.locales, options.timeout, (sourcePath, locale) => fileMapping[locale][sourcePath] ?? null, settings);
-}
-export async function postProcessTranslations(settings) {
-    // Localize static urls (/docs -> /[locale]/docs)
-    if (settings.options?.experimentalLocalizeStaticUrls) {
-        await localizeStaticUrls(settings);
-    }
-    // Localize static imports (/docs -> /[locale]/docs)
-    if (settings.options?.experimentalLocalizeStaticImports) {
-        await localizeStaticImports(settings);
-    }
-    // Flatten json files into a single file
-    if (settings.options?.experimentalFlattenJsonFiles) {
-        await flattenJsonFiles(settings);
-    }
-    // Copy files to the target locale
-    if (settings.options?.copyFiles) {
-        await copyFile(settings);
-    }
-}

package/dist/cli/flags.d.ts

@@ -1,3 +0,0 @@
-import { Command } from 'commander';
-export declare function attachTranslateFlags(command: Command): Command;
-export declare function attachAdditionalReactTranslateFlags(command: Command): Command;

package/dist/cli/flags.js

@@ -1,37 +0,0 @@
-import findFilepath from '../fs/findFilepath.js';
-const DEFAULT_TIMEOUT = 600;
-export function attachTranslateFlags(command) {
-    command
-        .option('-c, --config <path>', 'Filepath to config file, by default gt.config.json', findFilepath(['gt.config.json']))
-        .option('--api-key <key>', 'API key for General Translation cloud service')
-        .option('--project-id <id>', 'General Translation project ID')
-        .option('--version-id <id>', 'General Translation version ID')
-        .option('--default-language, --default-locale <locale>', 'Default locale (e.g., en)')
-        .option('--new, --locales <locales...>', 'Space-separated list of locales (e.g., en fr es)')
-        .option('--dry-run', 'Dry run, do not send updates to the General Translation API', false)
-        .option('--timeout <seconds>', 'Translation wait timeout in seconds', (value) => {
-        const parsedValue = parseInt(value, 10);
-        if (isNaN(parsedValue)) {
-            throw new Error('Not a number.');
-        }
-        if (parsedValue < 0) {
-            throw new Error('Timeout must be a positive number.');
-        }
-        return parsedValue;
-    }, DEFAULT_TIMEOUT)
-        .option('--publish', 'Publish translations to the CDN', false)
-        .option('--experimental-localize-static-urls', 'Triggering this will run a script after the cli tool that localizes all urls in content files. Currently only supported for md and mdx files.', false)
-        .option('--experimental-hide-default-locale', 'When localizing static locales, hide the default locale from the path', false)
-        .option('--experimental-flatten-json-files', 'Triggering this will flatten the json files into a single file. This is useful for projects that have a lot of json files.', false)
-        .option('--experimental-localize-static-imports', 'Triggering this will run a script after the cli tool that localizes all static imports in content files. Currently only supported for md and mdx files.', false);
-    return command;
-}
-export function attachAdditionalReactTranslateFlags(command) {
-    command
-        .option('--tsconfig, --jsconfig <path>', 'Path to custom jsconfig or tsconfig file', findFilepath(['./tsconfig.json', './jsconfig.json']))
-        .option('--dictionary <path>', 'Path to dictionary file')
-        .option('--src <paths...>', "Space-separated list of glob patterns containing the app's source code, by default 'src/**/*.{js,jsx,ts,tsx}' 'app/**/*.{js,jsx,ts,tsx}' 'pages/**/*.{js,jsx,ts,tsx}' 'components/**/*.{js,jsx,ts,tsx}'")
-        .option('--inline', 'Include inline <T> tags in addition to dictionary file', true)
-        .option('--ignore-errors', 'Ignore errors encountered while scanning for <T> tags', false);
-    return command;
-}

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

@@ -1,10 +0,0 @@
-type StagedVersionData = Record<string, {
-    fileName: string;
-    versionId: string;
-}>;
-export declare function updateVersions({ configDirectory, versionData, }: {
-    configDirectory: string;
-    versionData: StagedVersionData;
-}): Promise<void>;
-export declare function getStagedVersions(configDirectory: string): Promise<StagedVersionData>;
-export {};

package/dist/fs/config/updateVersions.js

@@ -1,30 +0,0 @@
-import fs from 'node:fs';
-import { displayUpdatedVersionsFile } from '../../console/logging.js';
-import { logError } from '../../console/logging.js';
-import path from 'node:path';
-const STAGED_VERSIONS_FILE = 'staged-versions.json';
-// Update the versions.json file with the new version ids
-// of the translations that were sent to the API
-export async function updateVersions({ configDirectory, versionData, }) {
-    const versionFilepath = path.join(configDirectory, STAGED_VERSIONS_FILE);
-    try {
-        fs.mkdirSync(configDirectory, { recursive: true });
-        fs.writeFileSync(versionFilepath, JSON.stringify(versionData, null, 2));
-        // show update in console
-        displayUpdatedVersionsFile(versionFilepath);
-    }
-    catch (error) {
-        logError(`An error occurred while updating ${versionFilepath}: ${error}`);
-    }
-}
-export async function getStagedVersions(configDirectory) {
-    try {
-        const versionFilepath = path.join(configDirectory, STAGED_VERSIONS_FILE);
-        const versionData = JSON.parse(fs.readFileSync(versionFilepath, 'utf8'));
-        return versionData;
-    }
-    catch (error) {
-        logError(`An error occurred while getting staged versions: ${error}`);
-        return {};
-    }
-}

package/dist/types/files.d.ts

@@ -1 +0,0 @@
-export type FileMapping = Record<string, Record<string, string>>;

package/dist/types/files.js

@@ -1 +0,0 @@
-export {};

package/dist/utils/hash.d.ts

@@ -1,6 +0,0 @@
-/**
- * Hashes a string using SHA-256 algorithm.
- * @param {string} string - The string to be hashed.
- * @returns {string} The hashed string.
- */
-export declare function hashStringSync(string: string): string;

package/dist/utils/hash.js

@@ -1,11 +0,0 @@
-import crypto from 'crypto';
-/**
- * Hashes a string using SHA-256 algorithm.
- * @param {string} string - The string to be hashed.
- * @returns {string} The hashed string.
- */
-export function hashStringSync(string) {
-    const hash = crypto.createHash('sha256');
-    hash.update(string);
-    return hash.digest('hex');
-}