gtx-cli 1.2.15 → 1.2.17

package/dist/fs/config/parseFilesConfig.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveLocaleFiles = resolveLocaleFiles;
+exports.resolveFiles = resolveFiles;
+const node_path_1 = __importDefault(require("node:path"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const supportedFiles_1 = require("../../formats/files/supportedFiles");
+const console_1 = require("../../console");
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Resolves the files from the files object
+ * Replaces [locale] with the actual locale in the files
+ *
+ * @param files - The files object
+ * @param locale - The locale to replace [locale] with
+ * @returns The resolved files
+ */
+function resolveLocaleFiles(files, locale) {
+    const result = {};
+    for (const fileType of supportedFiles_1.SUPPORTED_FILE_EXTENSIONS) {
+        result[fileType] = files[fileType]?.map((filepath) => filepath.replace(/\[locale\]/g, locale));
+    }
+    // Replace [locale] with locale in all paths
+    result.gt = files.gt?.replace(/\[locale\]/g, locale);
+    return result;
+}
+/**
+ * Resolves the files from the files object
+ * Performs glob pattern expansion on the files
+ * Replaces [locale] with the actual locale in the files
+ *
+ * @param files - The files object
+ * @returns The resolved files
+ */
+function resolveFiles(files, locale) {
+    // Initialize result object with empty arrays for each file type
+    const result = {};
+    const placeholderResult = {};
+    const transformPaths = {};
+    // Process GT files
+    if (files.gt?.output) {
+        placeholderResult.gt = files.gt.output;
+    }
+    for (const fileType of supportedFiles_1.SUPPORTED_FILE_EXTENSIONS) {
+        // ==== TRANSFORMS ==== //
+        if (files[fileType]?.transform &&
+            !Array.isArray(files[fileType].transform)) {
+            transformPaths[fileType] = files[fileType].transform;
+        }
+        // ==== PLACEHOLDERS ==== //
+        if (files[fileType]?.include) {
+            const filePaths = expandGlobPatterns(files[fileType].include, files[fileType]?.exclude || [], locale, transformPaths[fileType] || undefined);
+            result[fileType] = filePaths.resolvedPaths;
+            placeholderResult[fileType] = filePaths.placeholderPaths;
+        }
+    }
+    return {
+        resolvedPaths: result,
+        placeholderPaths: placeholderResult,
+        transformPaths: transformPaths,
+    };
+}
+// Helper function to expand glob patterns
+function expandGlobPatterns(includePatterns, excludePatterns, locale, transformPatterns) {
+    // Expand glob patterns to include all matching files
+    const resolvedPaths = [];
+    const placeholderPaths = [];
+    // Process include patterns
+    for (const pattern of includePatterns) {
+        // Track positions where [locale] appears in the original pattern
+        // It must be included in the pattern, otherwise the CLI tool will not be able to find the correct output path
+        // Warn if it's not included
+        if (!pattern.includes('[locale]') && !transformPatterns) {
+            (0, console_1.logWarning)(chalk_1.default.yellow(`Pattern "${pattern}" does not include [locale], so the CLI tool may incorrectly save translated files.`));
+        }
+        const localePositions = [];
+        let searchIndex = 0;
+        const localeTag = '[locale]';
+        while (true) {
+            const foundIndex = pattern.indexOf(localeTag, searchIndex);
+            if (foundIndex === -1)
+                break;
+            localePositions.push(foundIndex);
+            searchIndex = foundIndex + localeTag.length;
+        }
+        const expandedPattern = pattern.replace(/\[locale\]/g, locale);
+        // Resolve the absolute pattern path
+        const absolutePattern = node_path_1.default.resolve(process.cwd(), expandedPattern);
+        // Prepare exclude patterns with locale replaced
+        const expandedExcludePatterns = excludePatterns.map((p) => node_path_1.default.resolve(process.cwd(), p.replace(/\[locale\]/g, locale)));
+        // Use fast-glob to find all matching files, excluding the patterns
+        const matches = fast_glob_1.default.sync(absolutePattern, {
+            absolute: true,
+            ignore: expandedExcludePatterns,
+        });
+        resolvedPaths.push(...matches);
+        // For each match, create a version with [locale] in the correct positions
+        matches.forEach((match) => {
+            // Convert to relative path to make replacement easier
+            const relativePath = node_path_1.default.relative(process.cwd(), match);
+            let originalRelativePath = relativePath;
+            // Replace locale with [locale] at each tracked position
+            if (localePositions.length > 0) {
+                // We need to account for path resolution differences
+                // This is a simplified approach - we'll replace all instances of the locale
+                // but only in path segments where we expect it based on the original pattern
+                const pathParts = relativePath.split(node_path_1.default.sep);
+                const patternParts = pattern.split(/[\/\\]/); // Handle both slash types
+                for (let i = 0; i < pathParts.length; i++) {
+                    if (i < patternParts.length) {
+                        if (patternParts[i].includes(localeTag)) {
+                            // This segment should have the locale replaced
+                            pathParts[i] = pathParts[i].replace(locale, localeTag);
+                        }
+                    }
+                }
+                originalRelativePath = pathParts.join(node_path_1.default.sep);
+            }
+            // Convert back to absolute path
+            const originalPath = node_path_1.default.resolve(process.cwd(), originalRelativePath);
+            placeholderPaths.push(originalPath);
+        });
+    }
+    return { resolvedPaths, placeholderPaths };
+}

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

@@ -0,0 +1,15 @@
+import { FilesOptions, SupportedFrameworks } from '../../types';
+/**
+ * Checks if the config file exists.
+ * If yes, make sure make sure projectId is correct
+ * If not, creates a new JSON file at the given filepath and writes the provided config object to it.
+ * @param {string} configFilepath - The path to the config file.
+ * @param {Record<string, any>} configObject - The config object to write if the file does not exist.
+ */
+export default function createOrUpdateConfig(configFilepath: string, options: {
+    projectId?: string;
+    defaultLocale?: string;
+    locales?: string[];
+    files?: FilesOptions;
+    framework?: SupportedFrameworks;
+}): Promise<string>;

package/dist/fs/config/setupConfig.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createOrUpdateConfig;
+const node_fs_1 = __importDefault(require("node:fs"));
+const console_1 = require("../../console");
+/**
+ * Checks if the config file exists.
+ * If yes, make sure make sure projectId is correct
+ * If not, creates a new JSON file at the given filepath and writes the provided config object to it.
+ * @param {string} configFilepath - The path to the config file.
+ * @param {Record<string, any>} configObject - The config object to write if the file does not exist.
+ */
+async function createOrUpdateConfig(configFilepath, options) {
+    // Filter out empty string values from the config object
+    const newContent = {
+        ...(options.projectId && { projectId: options.projectId }),
+        ...(options.defaultLocale && { defaultLocale: options.defaultLocale }),
+        ...(options.files && { files: options.files }),
+        ...(options.framework && { framework: options.framework }),
+    };
+    try {
+        // if file exists
+        let oldContent = {};
+        if (node_fs_1.default.existsSync(configFilepath)) {
+            oldContent = JSON.parse(await node_fs_1.default.promises.readFile(configFilepath, 'utf-8'));
+        }
+        // merge old and new content
+        const mergedContent = {
+            ...oldContent,
+            ...newContent,
+        };
+        // Add locales to mergedContent if they exist
+        if (options.locales) {
+            mergedContent.locales = mergedContent.locales
+                ? [...new Set([...mergedContent.locales, ...options.locales])]
+                : options.locales;
+        }
+        // write to file
+        const mergedJsonContent = JSON.stringify(mergedContent, null, 2);
+        await node_fs_1.default.promises.writeFile(configFilepath, mergedJsonContent, 'utf-8');
+        // show update in console
+        (0, console_1.displayCreatedConfigFile)(configFilepath);
+    }
+    catch (error) {
+        (0, console_1.logError)(`An error occurred while updating ${configFilepath}: ${error}`);
+    }
+    return configFilepath;
+}

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

@@ -0,0 +1,11 @@
+/**
+ * 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, locales, stageTranslations, }: {
+    configFilepath: string;
+    projectId?: string;
+    _versionId?: string;
+    locales?: string[];
+    stageTranslations?: boolean;
+}): Promise<void>;

package/dist/fs/config/updateConfig.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = updateConfig;
+const node_fs_1 = __importDefault(require("node:fs"));
+const console_1 = require("../../console/console");
+/**
+ * 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.
+ */
+async function updateConfig({ configFilepath, projectId, _versionId, locales, stageTranslations, }) {
+    // Filter out empty string values from the config object
+    const newContent = {
+        ...(projectId && { projectId }),
+        ...(_versionId && { _versionId }),
+        ...(stageTranslations && { stageTranslations }),
+        // ...(locales && { locales }), // Don't override locales
+    };
+    try {
+        // if file exists
+        let oldContent = {};
+        if (node_fs_1.default.existsSync(configFilepath)) {
+            oldContent = JSON.parse(await node_fs_1.default.promises.readFile(configFilepath, 'utf-8'));
+        }
+        // merge old and new content
+        const mergedContent = {
+            ...oldContent,
+            ...newContent,
+        };
+        // write to file
+        const mergedJsonContent = JSON.stringify(mergedContent, null, 2);
+        await node_fs_1.default.promises.writeFile(configFilepath, mergedJsonContent, 'utf-8');
+        // show update in console
+        (0, console_1.displayUpdatedConfigFile)(configFilepath);
+    }
+    catch (error) {
+        (0, console_1.logError)(`An error occurred while updating ${configFilepath}: ${error}`);
+    }
+}

package/dist/fs/determineFramework.d.ts

@@ -0,0 +1,5 @@
+import { SupportedLibraries } from '../types';
+export declare function determineLibrary(): {
+    library: SupportedLibraries;
+    additionalModules: SupportedLibraries[];
+};

package/dist/fs/determineFramework.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.determineLibrary = determineLibrary;
+const chalk_1 = __importDefault(require("chalk"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const console_1 = require("../console");
+function determineLibrary() {
+    let library = 'base';
+    let additionalModules = [];
+    try {
+        // Get the current working directory (where the CLI is being run)
+        const cwd = process.cwd();
+        const packageJsonPath = node_path_1.default.join(cwd, 'package.json');
+        // Check if package.json exists
+        if (!node_fs_1.default.existsSync(packageJsonPath)) {
+            (0, console_1.logError)(chalk_1.default.red('No package.json found in the current directory. Please run this command from the root of your project.'));
+            return { library: 'base', additionalModules: [] };
+        }
+        // Read and parse package.json
+        const packageJson = JSON.parse(node_fs_1.default.readFileSync(packageJsonPath, 'utf8'));
+        const dependencies = {
+            ...packageJson.dependencies,
+            ...packageJson.devDependencies,
+        };
+        // Check for gt-next or gt-react in dependencies
+        if (dependencies['gt-next']) {
+            library = 'gt-next';
+        }
+        else if (dependencies['gt-react']) {
+            library = 'gt-react';
+        }
+        else if (dependencies['next-intl']) {
+            library = 'next-intl';
+        }
+        else if (dependencies['i18next']) {
+            library = 'i18next';
+        }
+        if (dependencies['i18next-icu']) {
+            additionalModules.push('i18next-icu');
+        }
+        // Fallback to base if neither is found
+        return { library, additionalModules };
+    }
+    catch (error) {
+        (0, console_1.logError)('Error determining framework: ' + String(error));
+        return { library: 'base', additionalModules: [] };
+    }
+}

package/dist/fs/findFilepath.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Resolve the file path from the given file path or default paths.
+ * @param {string} filePath - The file path to resolve.
+ * @param {string[]} defaultPaths - The default paths to check.
+ * @returns {string} - The resolved file path.
+ */
+export default function findFilepath(paths: string[], errorMessage?: string): string;
+/**
+ * Resolve the file paths from the given file paths or default paths.
+ * @param {string[]} paths - The file paths to resolve.
+ * @param {string} errorMessage - The error message to throw if no paths are found.
+ * @returns {string[]} - The resolved file paths.
+ */
+export declare function findFilepaths(paths: string[], errorMessage?: string): string[];
+export declare function getRelativePath(file: string, srcDirectory: string): string;
+/**
+ * Find a file in a directory based on a wildcard pattern.
+ * @param {string} filePattern - The wildcard pattern to search for.
+ * @param {string} file - The file to search for.
+ * @returns {string} - The path to the file.
+ */
+export declare function findFile(filePattern: string, file: string): string;
+/**
+ * Read a file and return the contents.
+ * @param {string} filePath - The path to the file to read.
+ * @returns {string} - The contents of the file.
+ */
+export declare function readFile(filePath: string): string;
+/**
+ * Find a file in a directory.
+ * @param {string} dir - The directory to search in.
+ * @param {string} file - The file to search for.
+ * @returns {string} - The path to the file.
+ */
+export declare function findFileInDir(dir: string, file: string): string;
+export declare function getRelative(absolutePath: string): string;

package/dist/fs/findFilepath.js

@@ -0,0 +1,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = findFilepath;
+exports.findFilepaths = findFilepaths;
+exports.getRelativePath = getRelativePath;
+exports.findFile = findFile;
+exports.readFile = readFile;
+exports.findFileInDir = findFileInDir;
+exports.getRelative = getRelative;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const console_1 = require("../console");
+/**
+ * Resolve the file path from the given file path or default paths.
+ * @param {string} filePath - The file path to resolve.
+ * @param {string[]} defaultPaths - The default paths to check.
+ * @returns {string} - The resolved file path.
+ */
+function findFilepath(paths, errorMessage = '') {
+    return findFilepaths(paths, errorMessage)?.[0] || '';
+}
+/**
+ * Resolve the file paths from the given file paths or default paths.
+ * @param {string[]} paths - The file paths to resolve.
+ * @param {string} errorMessage - The error message to throw if no paths are found.
+ * @returns {string[]} - The resolved file paths.
+ */
+function findFilepaths(paths, errorMessage = '') {
+    const resolvedPaths = [];
+    for (const possiblePath of paths) {
+        if (node_fs_1.default.existsSync(possiblePath)) {
+            resolvedPaths.push(possiblePath);
+        }
+    }
+    if (errorMessage) {
+        (0, console_1.logError)(errorMessage);
+        process.exit(1);
+    }
+    return resolvedPaths;
+}
+function getRelativePath(file, srcDirectory) {
+    // Create relative path from src directory and remove extension
+    return node_path_1.default
+        .relative(srcDirectory, file.replace(/\.[^/.]+$/, '') // Remove file extension
+    )
+        .replace(/\\/g, '.') // Replace Windows backslashes with dots
+        .split(/[./]/) // Split on dots or forward slashes
+        .filter(Boolean) // Remove empty segments that might cause extra dots
+        .map((segment) => segment.replace(/[^a-zA-Z0-9]/g, '_').toLowerCase()) // Convert each segment to snake case
+        .join('.'); // Rejoin with dots
+}
+/**
+ * Find a file in a directory based on a wildcard pattern.
+ * @param {string} filePattern - The wildcard pattern to search for.
+ * @param {string} file - The file to search for.
+ * @returns {string} - The path to the file.
+ */
+function findFile(filePattern, file) {
+    // Handle wildcard pattern by replacing the wildcard with the file parameter
+    const resolvedPath = filePattern.replace(/\*/, file);
+    if (node_fs_1.default.existsSync(resolvedPath) && node_fs_1.default.statSync(resolvedPath).isFile()) {
+        return node_fs_1.default.readFileSync(resolvedPath, 'utf8');
+    }
+    return '';
+}
+/**
+ * Read a file and return the contents.
+ * @param {string} filePath - The path to the file to read.
+ * @returns {string} - The contents of the file.
+ */
+function readFile(filePath) {
+    if (node_fs_1.default.existsSync(filePath) && node_fs_1.default.statSync(filePath).isFile()) {
+        return node_fs_1.default.readFileSync(filePath, 'utf8');
+    }
+    return '';
+}
+/**
+ * Find a file in a directory.
+ * @param {string} dir - The directory to search in.
+ * @param {string} file - The file to search for.
+ * @returns {string} - The path to the file.
+ */
+function findFileInDir(dir, file) {
+    const resolvedPath = node_path_1.default.join(dir, file);
+    try {
+        if (node_fs_1.default.existsSync(resolvedPath)) {
+            return node_fs_1.default.readFileSync(resolvedPath, 'utf8');
+        }
+    }
+    catch (error) {
+        (0, console_1.logError)('Error finding file in directory: ' + String(error));
+    }
+    return '';
+}
+function getRelative(absolutePath) {
+    const path2 = node_path_1.default.resolve(absolutePath);
+    return node_path_1.default.relative(process.cwd(), path2);
+}

package/dist/fs/findJsxFilepath.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Recursively scan the directory and collect all files with the specified extensions,
+ * excluding files or directories that start with a dot (.)
+ * @param dir - The directory to scan
+ * @returns An array of file paths
+ */
+export declare function getFiles(dir: string): string[];

package/dist/fs/findJsxFilepath.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFiles = getFiles;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+// Define the file extensions to look for
+const extensions = ['.js', '.jsx', '.tsx'];
+/**
+ * Recursively scan the directory and collect all files with the specified extensions,
+ * excluding files or directories that start with a dot (.)
+ * @param dir - The directory to scan
+ * @returns An array of file paths
+ */
+function getFiles(dir) {
+    let files = [];
+    const items = node_fs_1.default.readdirSync(dir);
+    for (const item of items) {
+        // Skip hidden files and directories
+        if (item.startsWith('.'))
+            continue;
+        const fullPath = node_path_1.default.join(dir, item);
+        const stat = node_fs_1.default.statSync(fullPath);
+        if (stat.isDirectory()) {
+            // Recursively scan subdirectories
+            files = files.concat(getFiles(fullPath));
+        }
+        else if (extensions.includes(node_path_1.default.extname(item))) {
+            // Add files with the specified extensions
+            files.push(fullPath);
+        }
+    }
+    return files;
+}

package/dist/fs/index.d.ts

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

package/dist/fs/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/fs/loadJSON.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Loads a JSON file from a given filepath, returning null if the file is not found or the JSON doesn't parse.
+ * @param {string} filepath - The path to the JSON file.
+ * @returns {Record<string, any> | null} - The parsed JSON object or null if an error occurs.
+ */
+export default function loadJSON(filepath: string): Record<string, any> | null;

package/dist/fs/loadJSON.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = loadJSON;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * Loads a JSON file from a given filepath, returning null if the file is not found or the JSON doesn't parse.
+ * @param {string} filepath - The path to the JSON file.
+ * @returns {Record<string, any> | null} - The parsed JSON object or null if an error occurs.
+ */
+function loadJSON(filepath) {
+    try {
+        const data = node_fs_1.default.readFileSync(node_path_1.default.resolve(filepath), 'utf-8');
+        return JSON.parse(data);
+    }
+    catch (error) {
+        // Return null if the file is not found or JSON parsing fails
+        return null;
+    }
+}

package/dist/fs/saveJSON.d.ts

@@ -0,0 +1 @@
+export declare function saveJSON(filepath: string, data: Record<string, any>): Promise<void>;

package/dist/fs/saveJSON.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveJSON = saveJSON;
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+async function saveJSON(filepath, data) {
+    // Ensure directory exists
+    await node_fs_1.default.promises.mkdir(node_path_1.default.dirname(filepath), { recursive: true });
+    await node_fs_1.default.promises.writeFile(filepath, JSON.stringify(data, null, 2));
+}

package/dist/fs/utils.d.ts

@@ -0,0 +1 @@
+export declare function resolveProjectId(): string | undefined;

package/dist/fs/utils.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveProjectId = resolveProjectId;
+function resolveProjectId() {
+    const CANDIDATES = [
+        process.env.GT_PROJECT_ID, // any server side, Remix
+        process.env.NEXT_PUBLIC_GT_PROJECT_ID, // Next.js
+        process.env.VITE_GT_PROJECT_ID, // Vite
+        process.env.REACT_APP_GT_PROJECT_ID, // Create React App
+        process.env.REDWOOD_ENV_GT_PROJECT_ID, // RedwoodJS
+        process.env.GATSBY_GT_PROJECT_ID, // Gatsby
+        process.env.EXPO_PUBLIC_GT_PROJECT_ID, // Expo (React Native)
+        process.env.RAZZLE_GT_PROJECT_ID, // Razzle
+        process.env.UMI_GT_PROJECT_ID, // UmiJS
+        process.env.BLITZ_PUBLIC_GT_PROJECT_ID, // Blitz.js
+        process.env.PUBLIC_GT_PROJECT_ID, // WMR, Qwik (general "public" convention)
+    ];
+    return CANDIDATES.find((projectId) => projectId !== undefined);
+}

package/dist/hooks/postProcess.d.ts

@@ -0,0 +1,4 @@
+type Formatter = 'prettier' | 'biome' | 'eslint';
+export declare function detectFormatter(): Promise<Formatter | null>;
+export declare function formatFiles(filesUpdated: string[], formatter?: Formatter): Promise<void>;
+export {};