gt 0.10.0 → 2.7.0

package/dist/utils/headers.js

@@ -0,0 +1,14 @@
+export function getAuthHeaders(projectId, apiKey) {
+    const authHeaders = {
+        'x-gt-project-id': projectId,
+    };
+    if (apiKey) {
+        if (apiKey.startsWith('gtx-internal-')) {
+            authHeaders['x-gt-internal-api-key'] = apiKey;
+        }
+        else {
+            authHeaders['x-gt-api-key'] = apiKey;
+        }
+    }
+    return authHeaders;
+}

package/dist/utils/installPackage.d.ts

@@ -0,0 +1,3 @@
+import { PackageManager } from './packageManager.js';
+export declare function installPackage(packageName: string, packageManager: PackageManager, asDevDependency?: boolean, cwd?: string): Promise<void>;
+export declare function installPackageGlobal(packageName: string, version?: string): Promise<void>;

package/dist/utils/installPackage.js

@@ -0,0 +1,77 @@
+import chalk from 'chalk';
+import { spawn } from 'child_process';
+import { logger } from '../console/logger.js';
+export async function installPackage(packageName, packageManager, asDevDependency, cwd = process.cwd()) {
+    return new Promise((resolve, reject) => {
+        const command = packageManager.name;
+        const args = [packageManager.installCommand, packageName];
+        if (asDevDependency) {
+            args.push(packageManager.devDependencyFlag);
+        }
+        const childProcess = spawn(command, args, {
+            stdio: ['pipe', 'ignore', 'pipe'],
+            cwd,
+        });
+        let errorOutput = '';
+        if (childProcess.stderr) {
+            childProcess.stderr.on('data', (data) => {
+                errorOutput += data.toString();
+            });
+        }
+        childProcess.on('error', (error) => {
+            logger.error(chalk.red(`Installation error: ${error.message}`));
+            logger.info(`Please manually install ${packageName} with: ${packageManager.name} ${packageManager.installCommand} ${packageName}`);
+            reject(error);
+        });
+        childProcess.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                logger.error(chalk.red(`Installation failed with exit code ${code}`));
+                if (errorOutput) {
+                    logger.error(chalk.red(`Error details: ${errorOutput}`));
+                }
+                logger.info(`Please manually install ${packageName} with: ${packageManager.name} ${packageManager.installCommand} ${packageName}`);
+                reject(new Error(`Process exited with code ${code}`));
+            }
+        });
+    });
+}
+export async function installPackageGlobal(packageName, version) {
+    return new Promise((resolve, reject) => {
+        const command = 'npm';
+        const args = [
+            'install',
+            '-g',
+            version ? `${packageName}@${version}` : packageName,
+        ];
+        const childProcess = spawn(command, args, {
+            stdio: ['pipe', 'ignore', 'pipe'],
+        });
+        let errorOutput = '';
+        if (childProcess.stderr) {
+            childProcess.stderr.on('data', (data) => {
+                errorOutput += data.toString();
+            });
+        }
+        childProcess.on('error', (error) => {
+            logger.error(chalk.red(`Installation error: ${error.message}`));
+            logger.info(`Please manually install ${packageName} with: npm install -g ${packageName}`);
+            reject(error);
+        });
+        childProcess.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                logger.error(chalk.red(`Installation failed with exit code ${code}`));
+                if (errorOutput) {
+                    logger.error(chalk.red(`Error details: ${errorOutput}`));
+                }
+                logger.info(`Please manually install ${packageName} with: npm install -g ${packageName}`);
+                reject(new Error(`Process exited with code ${code}`));
+            }
+        });
+    });
+}

package/dist/utils/localizeRelativeAssets.d.ts

@@ -0,0 +1,8 @@
+import { Settings } from '../types/index.js';
+type RewriteResult = {
+    content: string;
+    hasChanges: boolean;
+};
+export declare function localizeRelativeAssetsForContent(content: string, sourcePath: string, targetPath: string, cwd: string): RewriteResult;
+export default function localizeRelativeAssets(settings: Settings, targetLocales?: string[], includeFiles?: Set<string>): Promise<void>;
+export {};

package/dist/utils/localizeRelativeAssets.js

@@ -0,0 +1,166 @@
+import * as fs from 'fs';
+import path from 'node:path';
+import { unified } from 'unified';
+import remarkParse from 'remark-parse';
+import remarkMdx from 'remark-mdx';
+import remarkFrontmatter from 'remark-frontmatter';
+import remarkStringify from 'remark-stringify';
+import { visit } from 'unist-util-visit';
+import { escapeHtmlInTextNodes, normalizeCJKCharacters } from 'gt-remark';
+import { createFileMapping } from '../formats/files/fileMapping.js';
+function stripQueryAndHash(url) {
+    const match = url.match(/^[^?#]+/);
+    const base = match ? match[0] : url;
+    const suffix = url.slice(base.length);
+    return { base, suffix };
+}
+function isSkippableUrl(url) {
+    if (!url)
+        return true;
+    if (url.startsWith('/'))
+        return true;
+    if (/^(https?:)?\/\//i.test(url))
+        return true;
+    if (url.startsWith('data:'))
+        return true;
+    if (url.startsWith('#'))
+        return true;
+    if (url.startsWith('mailto:'))
+        return true;
+    if (url.startsWith('tel:'))
+        return true;
+    return false;
+}
+function toPosix(p) {
+    return p.replace(/\\/g, '/');
+}
+function isSubPath(child, parent) {
+    const rel = path.relative(parent, child);
+    return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+}
+export function localizeRelativeAssetsForContent(content, sourcePath, targetPath, cwd) {
+    let changed = false;
+    let ast;
+    try {
+        const processor = unified()
+            .use(remarkParse)
+            .use(remarkFrontmatter, ['yaml', 'toml'])
+            .use(remarkMdx);
+        ast = processor.runSync(processor.parse(content));
+    }
+    catch {
+        return { content, hasChanges: false };
+    }
+    const sourceDir = path.dirname(sourcePath);
+    const targetDir = path.dirname(targetPath);
+    const maybeRewrite = (url) => {
+        if (isSkippableUrl(url))
+            return null;
+        const { base, suffix } = stripQueryAndHash(url);
+        if (isSkippableUrl(base))
+            return null;
+        const targetResolved = path.resolve(targetDir, base);
+        if (fs.existsSync(targetResolved)) {
+            return null;
+        }
+        const sourceResolved = path.resolve(sourceDir, base);
+        if (!fs.existsSync(sourceResolved)) {
+            return null;
+        }
+        let newPath;
+        if (isSubPath(sourceResolved, cwd)) {
+            newPath = '/' + toPosix(path.relative(cwd, sourceResolved));
+        }
+        else {
+            const rel = toPosix(path.relative(targetDir, sourceResolved));
+            newPath = rel || toPosix(path.basename(sourceResolved));
+        }
+        if (newPath === base)
+            return null;
+        changed = true;
+        return newPath + suffix;
+    };
+    visit(ast, (node) => {
+        if (node.type === 'image' && typeof node.url === 'string') {
+            const newUrl = maybeRewrite(node.url);
+            if (newUrl)
+                node.url = newUrl;
+            return;
+        }
+        if ((node.type === 'mdxJsxFlowElement' ||
+            node.type === 'mdxJsxTextElement') &&
+            node.name === 'img' &&
+            Array.isArray(node.attributes)) {
+            for (const attr of node.attributes) {
+                if (attr &&
+                    attr.type === 'mdxJsxAttribute' &&
+                    attr.name === 'src' &&
+                    typeof attr.value === 'string') {
+                    const newUrl = maybeRewrite(attr.value);
+                    if (newUrl)
+                        attr.value = newUrl;
+                }
+            }
+        }
+    });
+    try {
+        const s = unified()
+            .use(remarkFrontmatter, ['yaml', 'toml'])
+            .use(remarkMdx)
+            .use(normalizeCJKCharacters)
+            .use(escapeHtmlInTextNodes)
+            .use(remarkStringify, {
+            handlers: {
+                text(node) {
+                    return node.value;
+                },
+            },
+        });
+        const outTree = s.runSync(ast);
+        let out = s.stringify(outTree);
+        if (out.endsWith('\n') && !content.endsWith('\n'))
+            out = out.slice(0, -1);
+        if (content.startsWith('\n') && !out.startsWith('\n'))
+            out = '\n' + out;
+        return { content: out, hasChanges: changed };
+    }
+    catch {
+        return { content, hasChanges: false };
+    }
+}
+export default async function localizeRelativeAssets(settings, targetLocales, includeFiles) {
+    if (!settings.files ||
+        (Object.keys(settings.files.placeholderPaths).length === 1 &&
+            settings.files.placeholderPaths.gt)) {
+        return;
+    }
+    const { resolvedPaths: sourceFiles } = settings.files;
+    const locales = targetLocales || settings.locales;
+    const fileMapping = createFileMapping(sourceFiles, settings.files.placeholderPaths, settings.files.transformPaths, settings.locales, settings.defaultLocale);
+    const cwd = process.cwd();
+    const processPromises = Object.entries(fileMapping)
+        .filter(([locale]) => locales.includes(locale))
+        .map(async ([locale, filesMap]) => {
+        const reverseMap = new Map();
+        for (const [sourcePath, targetPath] of Object.entries(filesMap)) {
+            reverseMap.set(targetPath, sourcePath);
+        }
+        const targetFiles = Object.values(filesMap).filter((p) => (p.endsWith('.md') || p.endsWith('.mdx')) &&
+            (!includeFiles || includeFiles.has(p)));
+        await Promise.all(targetFiles.map(async (targetPath) => {
+            if (!fs.existsSync(targetPath))
+                return;
+            const sourcePath = reverseMap.get(targetPath);
+            if (!sourcePath)
+                return;
+            if (!fs.existsSync(sourcePath))
+                return;
+            const content = await fs.promises.readFile(targetPath, 'utf8');
+            const result = localizeRelativeAssetsForContent(content, sourcePath, targetPath, cwd);
+            if (result.hasChanges) {
+                await fs.promises.writeFile(targetPath, result.content);
+            }
+        }));
+    });
+    await Promise.all(processPromises);
+}

package/dist/utils/localizeStaticImports.d.ts

@@ -0,0 +1,15 @@
+import { Settings } from '../types/index.js';
+/**
+ * Localizes static imports in content files.
+ * Currently only supported for md and mdx files. (/docs/ -> /[locale]/docs/)
+ * @param settings - The settings object containing the project configuration.
+ * @returns void
+ *
+ * @TODO This is an experimental feature, and only works in very specific cases. This needs to be improved before
+ * it can be enabled by default.
+ *
+ * Before this becomes a non-experimental feature, we need to:
+ * - Support more file types
+ * - Support more complex paths
+ */
+export default function localizeStaticImports(settings: Settings, includeFiles?: Set<string>): Promise<void>;

package/dist/utils/localizeStaticImports.js

@@ -0,0 +1,397 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { createFileMapping } from '../formats/files/fileMapping.js';
+import micromatch from 'micromatch';
+import { unified } from 'unified';
+import remarkParse from 'remark-parse';
+import remarkMdx from 'remark-mdx';
+import remarkFrontmatter from 'remark-frontmatter';
+import { visit } from 'unist-util-visit';
+const { isMatch } = micromatch;
+/**
+ * Localizes static imports in content files.
+ * Currently only supported for md and mdx files. (/docs/ -> /[locale]/docs/)
+ * @param settings - The settings object containing the project configuration.
+ * @returns void
+ *
+ * @TODO This is an experimental feature, and only works in very specific cases. This needs to be improved before
+ * it can be enabled by default.
+ *
+ * Before this becomes a non-experimental feature, we need to:
+ * - Support more file types
+ * - Support more complex paths
+ */
+export default async function localizeStaticImports(settings, includeFiles) {
+    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);
+    // 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] && !includeFiles) {
+        const defaultLocaleFiles = [];
+        // Collect all .md and .mdx files from sourceFiles
+        if (sourceFiles.md) {
+            defaultLocaleFiles.push(...sourceFiles.md);
+        }
+        if (sourceFiles.mdx) {
+            defaultLocaleFiles.push(...sourceFiles.mdx);
+        }
+        if (defaultLocaleFiles.length > 0) {
+            const defaultPromise = Promise.all(defaultLocaleFiles.map(async (filePath) => {
+                // Check if file exists before processing
+                if (!fs.existsSync(filePath)) {
+                    return;
+                }
+                // Get file content
+                const fileContent = await fs.promises.readFile(filePath, 'utf8');
+                // Localize the file using default locale
+                const localizedFile = localizeStaticImportsForFile(fileContent, settings.defaultLocale, settings.defaultLocale, // Process as default locale
+                settings.options?.docsHideDefaultLocaleImport || false, settings.options?.docsImportPattern, settings.options?.excludeStaticImports, filePath, settings.options);
+                // Write the localized file back to the same path
+                await fs.promises.writeFile(filePath, localizedFile);
+            }));
+            processPromises.push(defaultPromise);
+        }
+    }
+    // Then process all other locales from fileMapping
+    const mappingPromises = Object.entries(fileMapping).map(async ([locale, filesMap]) => {
+        // Get all files that are md or mdx
+        const targetFiles = Object.values(filesMap).filter((p) => (p.endsWith('.md') || p.endsWith('.mdx')) &&
+            (!includeFiles || includeFiles.has(p)));
+        // Replace the placeholder path with the target path
+        await Promise.all(targetFiles.map(async (filePath) => {
+            // Check if file exists before processing
+            if (!fs.existsSync(filePath)) {
+                return;
+            }
+            // Get file content
+            const fileContent = await fs.promises.readFile(filePath, 'utf8');
+            // Localize the file
+            const localizedFile = localizeStaticImportsForFile(fileContent, settings.defaultLocale, locale, settings.options?.docsHideDefaultLocaleImport || false, settings.options?.docsImportPattern, settings.options?.excludeStaticImports, filePath, settings.options);
+            // Write the localized file to the target path
+            await fs.promises.writeFile(filePath, localizedFile);
+        }));
+    });
+    processPromises.push(...mappingPromises);
+    await Promise.all(processPromises);
+}
+/**
+ * Determines if an import path should be processed based on pattern matching
+ */
+function shouldProcessImportPath(importPath, patternHead, targetLocale, defaultLocale) {
+    const patternWithoutSlash = patternHead.replace(/\/$/, '');
+    if (targetLocale === defaultLocale) {
+        // For default locale processing, check if path contains the pattern
+        return importPath.includes(patternWithoutSlash);
+    }
+    else {
+        // For non-default locales, check if path starts with pattern
+        return importPath.includes(patternWithoutSlash);
+    }
+}
+/**
+ * Checks if an import path should be excluded based on exclusion patterns
+ */
+function isImportPathExcluded(importPath, exclude, defaultLocale) {
+    const excludePatterns = exclude.map((p) => p.replace(/\[locale\]/g, defaultLocale));
+    return excludePatterns.some((pattern) => isMatch(importPath, pattern));
+}
+/**
+ * Transforms import path for default locale processing
+ */
+function transformDefaultLocaleImportPath(fullPath, patternHead, defaultLocale, hideDefaultLocale) {
+    if (hideDefaultLocale) {
+        // Remove locale from imports that have it: '/snippets/en/file.mdx' -> '/snippets/file.mdx'
+        if (fullPath.includes(`/${defaultLocale}/`)) {
+            return fullPath.replace(`/${defaultLocale}/`, '/');
+        }
+        else if (fullPath.endsWith(`/${defaultLocale}`)) {
+            return fullPath.replace(`/${defaultLocale}`, '');
+        }
+        return null; // Path doesn't have default locale
+    }
+    else {
+        // Add locale to imports that don't have it: '/snippets/file.mdx' -> '/snippets/en/file.mdx'
+        if (fullPath.includes(`/${defaultLocale}/`) ||
+            fullPath.endsWith(`/${defaultLocale}`)) {
+            return null; // Already has default locale
+        }
+        if (fullPath.startsWith(patternHead)) {
+            const pathAfterHead = fullPath.slice(patternHead.length);
+            if (pathAfterHead) {
+                return `${patternHead}${defaultLocale}/${pathAfterHead}`;
+            }
+            else {
+                return `${patternHead.replace(/\/$/, '')}/${defaultLocale}`;
+            }
+        }
+        return null; // Path doesn't match pattern
+    }
+}
+/**
+ * Transforms import path for non-default locale processing with hideDefaultLocale=true
+ */
+function transformNonDefaultLocaleImportPathWithHidden(fullPath, patternHead, targetLocale, defaultLocale) {
+    // Check if already localized
+    if (fullPath.startsWith(`${patternHead}${targetLocale}/`) ||
+        fullPath === `${patternHead}${targetLocale}`) {
+        return null;
+    }
+    // Replace default locale with target locale
+    const expectedPathWithDefaultLocale = `${patternHead}${defaultLocale}`;
+    if (fullPath.startsWith(`${expectedPathWithDefaultLocale}/`) ||
+        fullPath === expectedPathWithDefaultLocale) {
+        return fullPath.replace(`${patternHead}${defaultLocale}`, `${patternHead}${targetLocale}`);
+    }
+    // Handle exact pattern match
+    if (fullPath === patternHead.replace(/\/$/, '')) {
+        return `${patternHead.replace(/\/$/, '')}/${targetLocale}`;
+    }
+    // Add target locale to path without any locale
+    const pathAfterHead = fullPath.slice(patternHead.length);
+    return pathAfterHead
+        ? `${patternHead}${targetLocale}/${pathAfterHead}`
+        : `${patternHead}${targetLocale}`;
+}
+/**
+ * Transforms import path for non-default locale processing with hideDefaultLocale=false
+ */
+function transformNonDefaultLocaleImportPath(fullPath, patternHead, targetLocale, defaultLocale) {
+    // If already localized to target, skip
+    const expectedPathWithTarget = `${patternHead}${targetLocale}`;
+    if (fullPath.startsWith(`${expectedPathWithTarget}/`) ||
+        fullPath === expectedPathWithTarget) {
+        return null;
+    }
+    const expectedPathWithLocale = `${patternHead}${defaultLocale}`;
+    if (fullPath.startsWith(`${expectedPathWithLocale}/`) ||
+        fullPath === expectedPathWithLocale) {
+        // Replace existing default locale with target locale
+        return fullPath.replace(`${patternHead}${defaultLocale}`, `${patternHead}${targetLocale}`);
+    }
+    else if (fullPath.startsWith(patternHead)) {
+        // Add target locale to path that doesn't have any locale
+        const pathAfterHead = fullPath.slice(patternHead.length);
+        if (pathAfterHead) {
+            return `${patternHead}${targetLocale}/${pathAfterHead}`;
+        }
+        else {
+            return `${patternHead.replace(/\/$/, '')}/${targetLocale}`;
+        }
+    }
+    return null; // Path doesn't match pattern
+}
+/**
+ * Main import path transformation function that delegates to specific scenarios
+ */
+function transformImportPath(fullPath, patternHead, targetLocale, defaultLocale, hideDefaultLocale, currentFilePath, projectRoot = process.cwd(), // fallback if not provided
+rewrites) {
+    // Apply explicit rewrites first (e.g., Docusaurus @site/docs -> @site/i18n/[locale]/...)
+    if (rewrites && rewrites.length > 0) {
+        const localeMap = {
+            '[locale]': targetLocale,
+            '[defaultLocale]': defaultLocale,
+        };
+        for (const { match, replace } of rewrites) {
+            const resolvedMatch = match.replace(/\[locale\]|\[defaultLocale\]/g, (token) => localeMap[token] || token);
+            if (fullPath.startsWith(resolvedMatch)) {
+                const remainder = fullPath.slice(resolvedMatch.length);
+                const resolvedReplace = replace.replace(/\[locale\]|\[defaultLocale\]/g, (token) => localeMap[token] || token);
+                let newPath;
+                if (resolvedReplace.endsWith('/')) {
+                    newPath = `${resolvedReplace}${remainder.replace(/^\//, '')}`;
+                }
+                else if (remainder.startsWith('/')) {
+                    newPath = `${resolvedReplace}${remainder}`;
+                }
+                else {
+                    newPath = `${resolvedReplace}/${remainder}`;
+                }
+                return newPath;
+            }
+        }
+    }
+    let newPath;
+    if (targetLocale === defaultLocale) {
+        newPath = transformDefaultLocaleImportPath(fullPath, patternHead, defaultLocale, hideDefaultLocale);
+    }
+    else if (hideDefaultLocale) {
+        newPath = transformNonDefaultLocaleImportPathWithHidden(fullPath, patternHead, targetLocale, defaultLocale);
+    }
+    else {
+        newPath = transformNonDefaultLocaleImportPath(fullPath, patternHead, targetLocale, defaultLocale);
+    }
+    if (!newPath)
+        return null;
+    if (currentFilePath) {
+        let resolvedPath;
+        if (newPath.startsWith('/')) {
+            // Interpret as project-root relative
+            resolvedPath = path.join(projectRoot, newPath.replace(/^\//, ''));
+        }
+        else {
+            // Relative to current file
+            const currentDir = path.dirname(currentFilePath);
+            resolvedPath = path.resolve(currentDir, newPath);
+        }
+        if (!fs.existsSync(resolvedPath)) {
+            return null;
+        }
+    }
+    return newPath;
+}
+/**
+ * AST-based transformation for MDX files using remark-mdx
+ */
+function transformMdxImports(mdxContent, defaultLocale, targetLocale, hideDefaultLocale, pattern = '/[locale]', exclude = [], currentFilePath, options) {
+    const transformedImports = [];
+    // Don't auto-prefix relative patterns that start with . or ..
+    if (!pattern.startsWith('/') && !pattern.startsWith('.')) {
+        pattern = '/' + pattern;
+    }
+    const patternHead = pattern.split('[locale]')[0];
+    // Quick check: if the file doesn't contain the pattern, skip expensive AST parsing
+    // For default locale processing, we also need to check if content might need adjustment
+    if (targetLocale === defaultLocale) {
+        // For default locale files, we always need to check as we're looking for either:
+        // - paths without locale (when hideDefaultLocale=false)
+        // - paths with default locale (when hideDefaultLocale=true)
+        const patternWithoutSlash = patternHead.replace(/\/$/, '');
+        if (!mdxContent.includes(patternWithoutSlash)) {
+            return {
+                content: mdxContent,
+                hasChanges: false,
+                transformedImports: [],
+            };
+        }
+    }
+    else {
+        // For non-default locales, use the original logic
+        if (!mdxContent.includes(patternHead.replace(/\/$/, ''))) {
+            return {
+                content: mdxContent,
+                hasChanges: false,
+                transformedImports: [],
+            };
+        }
+    }
+    // Parse the MDX content into an AST
+    let processedAst;
+    try {
+        const parseProcessor = unified()
+            .use(remarkParse)
+            .use(remarkFrontmatter, ['yaml', 'toml'])
+            .use(remarkMdx);
+        const ast = parseProcessor.parse(mdxContent);
+        processedAst = parseProcessor.runSync(ast);
+    }
+    catch {
+        return transformImportsStringFallback(mdxContent, defaultLocale, targetLocale, hideDefaultLocale, pattern, exclude, currentFilePath, options);
+    }
+    let content = mdxContent;
+    // Visit only mdxjsEsm nodes (import/export statements) to collect replacements
+    visit(processedAst, 'mdxjsEsm', (node) => {
+        if (node.value && node.value.includes(patternHead.replace(/\/$/, ''))) {
+            // Find import lines that need transformation
+            const lines = node.value.split('\n');
+            lines.forEach((line) => {
+                // Only process import lines that match our pattern
+                if (!line.trim().startsWith('import ')) {
+                    return;
+                }
+                // Check if this line should be processed
+                if (!shouldProcessImportPath(line, patternHead, targetLocale, defaultLocale)) {
+                    return;
+                }
+                // Extract the path from the import statement
+                const quotes = ['"', "'", '`'];
+                for (const quote of quotes) {
+                    // Try both with and without trailing slash
+                    let startPattern = `${quote}${patternHead}`;
+                    let startIndex = line.indexOf(startPattern);
+                    // If pattern has trailing slash but path doesn't, try without slash
+                    if (startIndex === -1 && patternHead.endsWith('/')) {
+                        const patternWithoutSlash = patternHead.slice(0, -1);
+                        startPattern = `${quote}${patternWithoutSlash}`;
+                        startIndex = line.indexOf(startPattern);
+                    }
+                    if (startIndex === -1)
+                        continue;
+                    const pathStart = startIndex + 1; // After the quote
+                    const pathEnd = line.indexOf(quote, pathStart);
+                    if (pathEnd === -1)
+                        continue;
+                    const fullPath = line.slice(pathStart, pathEnd);
+                    // Transform the import path
+                    const newPath = transformImportPath(fullPath, patternHead, targetLocale, defaultLocale, hideDefaultLocale, currentFilePath, process.cwd(), options?.docsImportRewrites);
+                    if (!newPath) {
+                        continue; // No transformation needed
+                    }
+                    // Check exclusions
+                    if (isImportPathExcluded(fullPath, exclude, defaultLocale)) {
+                        continue;
+                    }
+                    // Apply the transformation to the original content
+                    // Simply replace the import path with the new path
+                    content = content.replace(`${quote}${fullPath}${quote}`, `${quote}${newPath}${quote}`);
+                    transformedImports.push({ originalPath: fullPath, newPath });
+                    break;
+                }
+            });
+        }
+    });
+    return {
+        content,
+        hasChanges: transformedImports.length > 0,
+        transformedImports,
+    };
+}
+/**
+ * String-based fallback for import localization when MDX parsing fails (e.g., on .md files)
+ */
+function transformImportsStringFallback(mdxContent, defaultLocale, targetLocale, hideDefaultLocale, pattern = '/[locale]', exclude = [], currentFilePath, options) {
+    const transformedImports = [];
+    if (!pattern.startsWith('/') && !pattern.startsWith('.')) {
+        pattern = '/' + pattern;
+    }
+    const patternHead = pattern.split('[locale]')[0];
+    let content = mdxContent;
+    const importRegex = /import\s+[^'"]*['"]([^'"]+)['"]\s*;?/g;
+    let match;
+    while ((match = importRegex.exec(mdxContent)) !== null) {
+        const fullMatch = match[0];
+        const importPath = match[1];
+        if (!shouldProcessImportPath(importPath, patternHead, targetLocale, defaultLocale)) {
+            continue;
+        }
+        if (isImportPathExcluded(importPath, exclude, defaultLocale)) {
+            continue;
+        }
+        const newPath = transformImportPath(importPath, patternHead, targetLocale, defaultLocale, hideDefaultLocale, currentFilePath, process.cwd(), options?.docsImportRewrites);
+        if (!newPath)
+            continue;
+        const updatedImport = fullMatch.replace(importPath, newPath);
+        content = content.replace(fullMatch, updatedImport);
+        transformedImports.push({ originalPath: importPath, newPath });
+    }
+    return {
+        content,
+        hasChanges: transformedImports.length > 0,
+        transformedImports,
+    };
+}
+/**
+ * AST-based transformation for MDX files only
+ */
+function localizeStaticImportsForFile(file, defaultLocale, targetLocale, hideDefaultLocale, pattern = '/[locale]', // eg /docs/[locale] or /[locale]
+exclude = [], currentFilePath, options) {
+    // For MDX files, use AST-based transformation
+    const result = transformMdxImports(file, defaultLocale, targetLocale, hideDefaultLocale, pattern, exclude, currentFilePath, options);
+    return result.content;
+}