gtx-cli 2.0.9 → 2.0.10

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # gtx-cli
 
+## 2.0.10
+
+### Patch Changes
+
+- [#499](https://github.com/generaltranslation/gt/pull/499) [`0793ef7`](https://github.com/generaltranslation/gt/commit/0793ef7f0d5b391805d072ff0c251fe43fa58b29) Thanks [@ErnestM1234](https://github.com/ErnestM1234)! - feat: add localization for imports
+
 ## 2.0.9
 
 ### Patch Changes

package/dist/cli/base.d.ts

@@ -10,6 +10,7 @@ export type TranslateOptions = {
     experimentalLocalizeStaticUrls?: boolean;
     experimentalHideDefaultLocale?: boolean;
     experimentalFlattenJsonFiles?: boolean;
+    experimentalLocalizeStaticImports?: boolean;
 };
 export type LoginOptions = {
     keyType?: 'development' | 'production';

package/dist/cli/base.js

@@ -16,6 +16,8 @@ import { retrieveCredentials, setCredentials } from '../utils/credentials.js';
 import { areCredentialsSet } from '../utils/credentials.js';
 import localizeStaticUrls from '../utils/localizeStaticUrls.js';
 import flattenJsonFiles from '../utils/flattenJsonFiles.js';
+import localizeStaticImports from '../utils/localizeStaticImports.js';
+import copyFile from '../fs/copyFile.js';
 export class BaseCLI {
     library;
     additionalModules;
@@ -54,6 +56,7 @@ export class BaseCLI {
             .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)
             .action(async (initOptions) => {
             displayHeader('Starting translation...');
             const settings = await generateSettings(initOptions);
@@ -181,10 +184,18 @@ See the docs for more information: https://generaltranslation.com/docs/react/tut
         if (settings.experimentalLocalizeStaticUrls) {
             await localizeStaticUrls(settings);
         }
+        // Localize static imports (/docs -> /[locale]/docs)
+        if (settings.experimentalLocalizeStaticImports) {
+            await localizeStaticImports(settings);
+        }
         // Flatten json files into a single file
         if (settings.experimentalFlattenJsonFiles) {
             await flattenJsonFiles(settings);
         }
+        // Copy files to the target locale
+        if (settings.options?.copyFiles) {
+            await copyFile(settings);
+        }
     }
     async handleSetupReactCommand(options) {
         await handleSetupReactCommand(options);

package/dist/cli/react.js

@@ -78,6 +78,7 @@ export class ReactCLI extends BaseCLI {
             .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)
             .action(async (options) => {
             displayHeader('Translating project...');
             await this.handleTranslate(options);

package/dist/config/generateSettings.js

@@ -64,6 +64,17 @@ export async function generateSettings(options, cwd = process.cwd()) {
         !options.options?.docsUrlPattern.includes('[locale]')) {
         logErrorAndExit('Failed to localize static urls: URL pattern must include "[locale]" to denote the location of the locale');
     }
+    if (options.options?.docsImportPattern &&
+        !options.options?.docsImportPattern.includes('[locale]')) {
+        logErrorAndExit('Failed to localize static imports: Import pattern must include "[locale]" to denote the location of the locale');
+    }
+    if (options.options?.copyFiles) {
+        for (const file of options.options.copyFiles) {
+            if (!file.includes('[locale]')) {
+                logErrorAndExit('Failed to copy files: File path must include "[locale]" to denote the location of the locale');
+            }
+        }
+    }
     // merge options
     const mergedOptions = { ...gtConfig, ...options };
     // merge locales

package/dist/config/optionPresets.js

@@ -21,6 +21,22 @@ export function generatePreset(preset) {
                             },
                         },
                     },
+                    // Enable this when support multiple language objects in array
+                    // '$.redirects': {
+                    //   type: 'array',
+                    //   key: '$.language',
+                    //   include: [],
+                    //   transform: {
+                    //     '$.source': {
+                    //       match: '^/{locale}/(.*)$',
+                    //       replace: '/{locale}/$1',
+                    //     },
+                    //     '$.destination': {
+                    //       match: '^/{locale}/(.*)$',
+                    //       replace: '/{locale}/$1',
+                    //     },
+                    //   },
+                    // },
                 },
             };
         default:

package/dist/formats/json/utils.js

@@ -29,7 +29,7 @@ export function findMatchingItemArray(locale, sourceObjectOptions, sourceObjectP
             exit(1);
         }
         // Validate the key is the identifying locale property
-        if (!keyCandidates[0] ||
+        if (!keyCandidates.length ||
             identifyingLocaleProperty !== keyCandidates[0].value) {
             continue;
         }

package/dist/fs/copyFile.d.ts

@@ -0,0 +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 & TranslateOptions): Promise<void>;

package/dist/fs/copyFile.js

@@ -0,0 +1,39 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { logError } from '../console/logging.js';
+/**
+ * Copy a file to target locale without translation
+ *
+ * This is a naive approach, does not allow for wild cards
+ */
+export default async function copyFile(settings) {
+    if (!settings.options?.copyFiles || settings.options.copyFiles.length === 0) {
+        return;
+    }
+    // Construct a map of source paths to target paths
+    const copyFiles = settings.options.copyFiles.reduce((paths, filePathTemplate) => {
+        const sourcePath = path.join(process.cwd(), filePathTemplate.replace('[locale]', settings.defaultLocale));
+        if (!fs.existsSync(sourcePath)) {
+            logError(`Failed to copy files: File path does not exist: ${sourcePath}`);
+            return paths;
+        }
+        paths[sourcePath] = [];
+        for (const locale of settings.locales) {
+            if (locale === settings.defaultLocale)
+                continue;
+            const targetPath = path.join(process.cwd(), filePathTemplate.replace('[locale]', locale));
+            paths[sourcePath].push(targetPath);
+        }
+        return paths;
+    }, {});
+    // Copy each file to the target locale
+    for (const sourcePath in copyFiles) {
+        for (const targetPath of copyFiles[sourcePath]) {
+            // Ensure the target directory exists
+            const targetDir = path.dirname(targetPath);
+            await fs.promises.mkdir(targetDir, { recursive: true });
+            // Copy the file
+            await fs.promises.copyFile(sourcePath, targetPath);
+        }
+    }
+}

package/dist/types/index.d.ts

@@ -20,6 +20,7 @@ export type Options = {
     experimentalLocalizeStaticUrls?: boolean;
     experimentalHideDefaultLocale?: boolean;
     experimentalFlattenJsonFiles?: boolean;
+    experimentalLocalizeStaticImports?: boolean;
 };
 export type WrapOptions = {
     src?: string[];
@@ -99,6 +100,9 @@ export type AdditionalOptions = {
         [fileGlob: string]: JsonSchema;
     };
     docsUrlPattern?: string;
+    docsImportPattern?: string;
+    docsHideDefaultLocaleImport?: boolean;
+    copyFiles?: string[];
 };
 export type JsonSchema = {
     preset?: 'mintlify';
@@ -112,10 +116,11 @@ export type SourceObjectOptions = {
     include: string[];
     key?: string;
     localeProperty?: string;
-    transform?: {
-        [transformPath: string]: {
-            match?: string;
-            replace: string;
-        };
+    transform?: TransformOptions;
+};
+export type TransformOptions = {
+    [transformPath: string]: {
+        match?: string;
+        replace: string;
     };
 };

package/dist/utils/localizeStaticImports.d.ts

@@ -0,0 +1,15 @@
+import { Options, 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: Omit<Settings & Options, 'ignoreErrors' | 'suppressWarnings' | 'timeout'>): Promise<void>;

package/dist/utils/localizeStaticImports.js

@@ -0,0 +1,93 @@
+import * as fs from 'fs';
+import { createFileMapping } from '../formats/files/translate.js';
+import { logError } from '../console/logging.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 async function localizeStaticImports(settings) {
+    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);
+    // Process all file types at once with a single call
+    await Promise.all(Object.entries(fileMapping).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
+        await Promise.all(targetFiles.map(async (filePath) => {
+            // 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);
+            // Write the localized file to the target path
+            await fs.promises.writeFile(filePath, localizedFile);
+        }));
+    }));
+}
+// Naive find and replace, in the future, construct an AST
+function localizeStaticImportsForFile(file, defaultLocale, targetLocale, hideDefaultLocale, pattern = '/[locale]' // eg /docs/[locale] or /[locale]
+) {
+    if (!pattern.startsWith('/')) {
+        pattern = '/' + pattern;
+    }
+    // 1. Search for all instances of:
+    const patternHead = pattern.split('[locale]')[0];
+    let regex;
+    if (hideDefaultLocale) {
+        const trimmedPatternHead = patternHead.endsWith('/')
+            ? patternHead.slice(0, -1)
+            : patternHead;
+        // Match complete markdown links: `import { Foo } from '@/docs/[locale]/foo.md'`
+        regex = new RegExp(`import\\s+(.*?)\\s+from\\s+(["'])${trimmedPatternHead}(.*?)\\2`, 'g');
+    }
+    else {
+        // Match complete markdown links with default locale: `import { Foo } from '@/docs/${defaultLocale}/foo.md'`
+        regex = new RegExp(`import\\s+(.*?)\\s+from\\s+(["'])${patternHead}${defaultLocale}(.*?)\\2`, 'g');
+    }
+    const matches = file.match(regex);
+    if (!matches) {
+        return file;
+    }
+    // 2. Replace the default locale with the target locale in all matched instances
+    const localizedFile = file.replace(regex, (match, bindings, quoteType, pathContent) => {
+        // get the quote type
+        quoteType = match.match(/["']/)?.[0] || '"';
+        if (!quoteType) {
+            logError(`Failed to localize static imports: Import pattern must include quotes in ${pattern}`);
+            return match;
+        }
+        if (hideDefaultLocale) {
+            // For hideDefaultLocale, check if path already has target locale
+            if (pathContent) {
+                if (pathContent.startsWith(`${targetLocale}/`) ||
+                    pathContent === targetLocale) {
+                    return match; // Already localized
+                }
+            }
+            // Add target locale to the path
+            if (!pathContent || pathContent === '') {
+                return `import ${bindings} from ${quoteType}${patternHead}${targetLocale}${quoteType}`;
+            }
+            return `import ${bindings} from ${quoteType}${patternHead}${targetLocale}${pathContent}${quoteType}`;
+        }
+        else {
+            // For non-hideDefaultLocale, replace defaultLocale with targetLocale
+            // pathContent contains everything after the default locale (no leading slash if present)
+            return `import ${bindings} from ${quoteType}${patternHead}${targetLocale}${pathContent}${quoteType}`;
+        }
+    });
+    return localizedFile;
+}

package/dist/utils/localizeStaticUrls.js

@@ -28,7 +28,7 @@ export default async function localizeStaticUrls(settings) {
         // Replace the placeholder path with the target path
         await Promise.all(targetFiles.map(async (filePath) => {
             // Get file content
-            const fileContent = fs.readFileSync(filePath, 'utf8');
+            const fileContent = await fs.promises.readFile(filePath, 'utf8');
             // Localize the file
             const localizedFile = localizeStaticUrlsForFile(fileContent, settings.defaultLocale, locale, settings.experimentalHideDefaultLocale || false, settings.options?.docsUrlPattern);
             // Write the localized file to the target path

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtx-cli",
-  "version": "2.0.9",
+  "version": "2.0.10",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [