gtx-cli 2.6.29 → 2.6.30-alpha.0

package/dist/formats/json/utils.js

@@ -1,150 +0,0 @@
-import { getLocaleProperties } from 'generaltranslation';
-import { exitSync } from '../../console/logging.js';
-import { logger } from '../../console/logger.js';
-import { JSONPath } from 'jsonpath-plus';
-import { flattenJson } from './flattenJson.js';
-import path from 'node:path';
-import micromatch from 'micromatch';
-const { isMatch } = micromatch;
-// Find the matching source item in an array
-// where the key matches the identifying locale property
-// If no matching item is found, exit with an error
-export function findMatchingItemArray(locale, sourceObjectOptions, sourceObjectPointer, sourceObjectValue) {
-    const { identifyingLocaleProperty, localeKeyJsonPath } = getSourceObjectOptionsArray(locale, sourceObjectPointer, sourceObjectOptions);
-    // Use the json pointer key to locate the source item
-    const matchingItems = {};
-    for (const [index, item] of sourceObjectValue.entries()) {
-        // Get the key candidates
-        const keyCandidates = JSONPath({
-            json: item,
-            path: localeKeyJsonPath,
-            resultType: 'all',
-            flatten: true,
-            wrap: true,
-        });
-        if (!keyCandidates) {
-            logger.error(`Source item at path: ${sourceObjectPointer} does not have a key value at path: ${localeKeyJsonPath}`);
-            return exitSync(1);
-        }
-        else if (keyCandidates.length === 0) {
-            // If no key candidates, skip the item
-            continue;
-        }
-        else if (keyCandidates.length > 1) {
-            // If multiple key candidates, exit with an error
-            logger.error(`Source item at path: ${sourceObjectPointer} has multiple matching keys with path: ${localeKeyJsonPath}`);
-            return exitSync(1);
-        }
-        else if (identifyingLocaleProperty !== keyCandidates[0].value) {
-            // Validate the key is the identifying locale property
-            continue;
-        }
-        // Map the index to the source item
-        matchingItems[`/${index}`] = {
-            sourceItem: item,
-            keyParentProperty: keyCandidates[0].parentProperty,
-            keyPointer: keyCandidates[0].pointer,
-            index,
-        };
-    }
-    return matchingItems;
-}
-export function findMatchingItemObject(locale, sourceObjectPointer, sourceObjectOptions, sourceObjectValue) {
-    const { identifyingLocaleProperty } = getSourceObjectOptionsObject(locale, sourceObjectPointer, sourceObjectOptions);
-    // Locate the source item
-    if (sourceObjectValue[identifyingLocaleProperty]) {
-        return {
-            sourceItem: sourceObjectValue[identifyingLocaleProperty],
-            keyParentProperty: identifyingLocaleProperty,
-        };
-    }
-    return {
-        sourceItem: undefined,
-        keyParentProperty: identifyingLocaleProperty,
-    };
-}
-/**
- * Get the identifying locale property for an object
- * @param locale - The locale to get the identifying locale property for
- * @param sourceObjectPointer - The path to the source object
- * @param sourceObjectOptions - The source object options
- * @returns The identifying locale property
- */
-export function getIdentifyingLocaleProperty(locale, sourceObjectPointer, sourceObjectOptions) {
-    // Validate localeProperty
-    const localeProperty = sourceObjectOptions.localeProperty || 'code';
-    const identifyingLocaleProperty = getLocaleProperties(locale)[localeProperty];
-    if (!identifyingLocaleProperty) {
-        logger.error(`Source object options localeProperty is not a valid locale property at path: ${sourceObjectPointer}`);
-        return exitSync(1);
-    }
-    return identifyingLocaleProperty;
-}
-/**
- * Get the identifying locale property and the json path to the key for an array
- * @param locale - The locale to get the identifying locale property for
- * @param sourceObjectPointer - The path to the source object
- * @param sourceObjectOptions - The source object options
- * @returns The identifying locale property and the json path to the key
- */
-export function getSourceObjectOptionsArray(locale, sourceObjectPointer, sourceObjectOptions) {
-    const identifyingLocaleProperty = getIdentifyingLocaleProperty(locale, sourceObjectPointer, sourceObjectOptions);
-    const localeKeyJsonPath = sourceObjectOptions.key;
-    if (!localeKeyJsonPath) {
-        logger.error(`Source object options key is required for array at path: ${sourceObjectPointer}`);
-        return exitSync(1);
-    }
-    return { identifyingLocaleProperty, localeKeyJsonPath };
-}
-export function getSourceObjectOptionsObject(defaultLocale, sourceObjectPointer, sourceObjectOptions) {
-    const identifyingLocaleProperty = getIdentifyingLocaleProperty(defaultLocale, sourceObjectPointer, sourceObjectOptions);
-    const jsonPathKey = sourceObjectOptions.key;
-    if (jsonPathKey) {
-        logger.error(`Source object options key is not allowed for object at path: ${sourceObjectPointer}`);
-        return exitSync(1);
-    }
-    return { identifyingLocaleProperty };
-}
-/**
- * Generate a mapping of sourceObjectPointer to SourceObjectOptions
- * where the sourceObjectPointer is a jsonpointer to the array or object containing
- * @param jsonSchema - The json schema to generate the mapping from
- * @param originalJson - The original json to generate the mapping from
- * @returns A mapping of sourceObjectPointer to SourceObjectOptions
- */
-export function generateSourceObjectPointers(jsonSchema, originalJson) {
-    const sourceObjectPointers = Object.entries(jsonSchema).reduce((acc, [sourceObjectPath, sourceObjectOptions]) => {
-        const sourceObjects = flattenJson(originalJson, [sourceObjectPath]);
-        Object.entries(sourceObjects).forEach(([pointer, value]) => {
-            acc[pointer] = {
-                sourceObjectValue: value,
-                sourceObjectOptions,
-            };
-        });
-        return acc;
-    }, {});
-    return sourceObjectPointers;
-}
-export function validateJsonSchema(options, filePath) {
-    if (!options.jsonSchema) {
-        return null;
-    }
-    const fileGlobs = Object.keys(options.jsonSchema);
-    const matchingGlob = fileGlobs.find((fileGlob) => isMatch(path.relative(process.cwd(), filePath), fileGlob));
-    if (!matchingGlob || !options.jsonSchema[matchingGlob]) {
-        return null;
-    }
-    // Validate includes or composite
-    const jsonSchema = options.jsonSchema[matchingGlob];
-    if (jsonSchema.include && jsonSchema.composite) {
-        logger.error('include and composite cannot be used together in the same JSON schema');
-        return exitSync(1);
-        return null;
-    }
-    if (!jsonSchema.include && !jsonSchema.composite) {
-        logger.error('No include or composite property found in JSON schema');
-        return exitSync(1);
-        return null;
-    }
-    return jsonSchema;
-}

package/dist/formats/utils.d.ts

@@ -1,2 +0,0 @@
-import { LocaleProperties } from 'generaltranslation/types';
-export declare function replaceLocalePlaceholders(string: string, localeProperties: LocaleProperties): string;

package/dist/formats/utils.js

@@ -1,24 +0,0 @@
-// helper function to replace locale placeholders in a string
-// with the corresponding locale properties
-// ex: {locale} -> will be replaced with the locale code
-// ex: {localeName} -> will be replaced with the locale name
-export function replaceLocalePlaceholders(string, localeProperties) {
-    return string.replace(/\{(\w+)\}/g, (match, property) => {
-        // Handle common aliases
-        if (property === 'locale' || property === 'localeCode') {
-            return localeProperties.code;
-        }
-        if (property === 'localeName') {
-            return localeProperties.name;
-        }
-        if (property === 'localeNativeName') {
-            return localeProperties.nativeName;
-        }
-        // Check if the property exists in localeProperties
-        if (property in localeProperties) {
-            return localeProperties[property];
-        }
-        // Return the original placeholder if property not found
-        return match;
-    });
-}

package/dist/formats/yaml/mergeYaml.d.ts

@@ -1,5 +0,0 @@
-import { AdditionalOptions } from '../../types/index.js';
-export default function mergeYaml(originalContent: string, inputPath: string, options: AdditionalOptions, targets: {
-    translatedContent: string;
-    targetLocale: string;
-}[], defaultLocale: string): string[];

package/dist/formats/yaml/mergeYaml.js

@@ -1,61 +0,0 @@
-import JSONPointer from 'jsonpointer';
-import { exitSync } from '../../console/logging.js';
-import { logger } from '../../console/logger.js';
-import { validateYamlSchema } from './utils.js';
-import YAML from 'yaml';
-import { applyTransformations } from '../json/mergeJson.js';
-export default function mergeYaml(originalContent, inputPath, options, targets, defaultLocale) {
-    const yamlSchema = validateYamlSchema(options, inputPath);
-    if (!yamlSchema) {
-        return targets.map((target) => target.translatedContent);
-    }
-    let originalYaml;
-    try {
-        originalYaml = YAML.parse(originalContent);
-    }
-    catch {
-        logger.error(`Invalid YAML file: ${inputPath}`);
-        return exitSync(1);
-    }
-    // Unreachable (validated in validateYamlSchema, included for type check)
-    if (!yamlSchema.include) {
-        logger.error('No include property found in YAML schema');
-        return exitSync(1);
-    }
-    // Handle include
-    const output = [];
-    for (const target of targets) {
-        // Must clone the original YAML to avoid mutations
-        const mergedYaml = JSON.parse(JSON.stringify(originalYaml));
-        let translatedJson;
-        try {
-            translatedJson = JSON.parse(target.translatedContent);
-        }
-        catch {
-            // If parsing fails, treat as empty object to avoid crashes
-            translatedJson = {};
-        }
-        for (const [jsonPointer, translatedValue] of Object.entries(translatedJson)) {
-            try {
-                // Try to get the value - if this succeeds, the pointer exists
-                if (JSONPointer.get(mergedYaml, jsonPointer) == null) {
-                    continue;
-                }
-                // Set the new value regardless of what the current value is (including null/falsy)
-                JSONPointer.set(mergedYaml, jsonPointer, translatedValue);
-            }
-            catch {
-                // Silently ignore invalid or non-existent JSON pointers
-            }
-        }
-        // Apply transformations if they exist
-        if (yamlSchema.transform) {
-            applyTransformations(mergedYaml, yamlSchema.transform, target.targetLocale, defaultLocale);
-        }
-        output.push(YAML.stringify(mergedYaml));
-    }
-    if (!output.length) {
-        return [originalContent];
-    }
-    return output;
-}

package/dist/formats/yaml/parseYaml.d.ts

@@ -1,5 +0,0 @@
-import { AdditionalOptions } from '../../types/index.js';
-export default function parseYaml(content: string, filePath: string, options: AdditionalOptions): {
-    content: string;
-    fileFormat: 'JSON' | 'YAML';
-};

package/dist/formats/yaml/parseYaml.js

@@ -1,24 +0,0 @@
-import { exitSync } from '../../console/logging.js';
-import { logger } from '../../console/logger.js';
-import YAML from 'yaml';
-import { validateYamlSchema } from './utils.js';
-import { flattenJsonWithStringFilter } from '../json/flattenJson.js';
-export default function parseYaml(content, filePath, options) {
-    const yamlSchema = validateYamlSchema(options, filePath);
-    if (!yamlSchema) {
-        return { content, fileFormat: 'YAML' };
-    }
-    let yaml;
-    try {
-        yaml = YAML.parse(content);
-    }
-    catch {
-        logger.error(`Invalid YAML file: ${filePath}`);
-        return exitSync(1);
-    }
-    if (yamlSchema.include) {
-        const flattenedYaml = flattenJsonWithStringFilter(yaml, yamlSchema.include);
-        return { content: JSON.stringify(flattenedYaml), fileFormat: 'JSON' };
-    }
-    return { content, fileFormat: 'YAML' };
-}

package/dist/formats/yaml/utils.d.ts

@@ -1,2 +0,0 @@
-import { AdditionalOptions, YamlSchema } from '../../types/index.js';
-export declare function validateYamlSchema(options: AdditionalOptions, filePath: string): YamlSchema | null;

package/dist/formats/yaml/utils.js

@@ -1,23 +0,0 @@
-import { exitSync } from '../../console/logging.js';
-import { logger } from '../../console/logger.js';
-import micromatch from 'micromatch';
-const { isMatch } = micromatch;
-import path from 'path';
-export function validateYamlSchema(options, filePath) {
-    if (!options.yamlSchema) {
-        return null;
-    }
-    // Check if the file matches any of the yaml schema globs
-    const fileGlobs = Object.keys(options.yamlSchema);
-    const matchingGlob = fileGlobs.find((fileGlob) => isMatch(path.relative(process.cwd(), filePath), fileGlob));
-    if (!matchingGlob || !options.yamlSchema[matchingGlob]) {
-        return null;
-    }
-    // Validate includes
-    const yamlSchema = options.yamlSchema[matchingGlob];
-    if (!yamlSchema.include) {
-        logger.error('No include property found in YAML schema');
-        return exitSync(1);
-    }
-    return yamlSchema;
-}

package/dist/fs/clearLocaleDirs.d.ts

@@ -1,8 +0,0 @@
-/**
- * Clears translated files before writing new translations
- * @param filePaths - Set of translated file paths to clear
- * @param locales - Array of locale codes to match against
- * @param excludePatterns - Optional array of glob patterns to exclude from clearing (supports [locale] and [locales])
- * @param cwd - Current working directory for resolving relative exclude patterns (defaults to process.cwd())
- */
-export declare function clearLocaleDirs(filePaths: Set<string>, locales: string[], excludePatterns?: string[], cwd?: string): Promise<void>;

package/dist/fs/clearLocaleDirs.js

@@ -1,126 +0,0 @@
-import fs from 'fs/promises';
-import path from 'node:path';
-import { logger } from '../console/logger.js';
-import fg from 'fast-glob';
-import micromatch from 'micromatch';
-/**
- * Extracts locale directories from translated file paths.
- * Groups files by their immediate parent containing a locale code.
- * For example: "snippets/es/api-test/file.mdx" -> "snippets/es"
- */
-function extractLocaleDirectories(filePaths, locales) {
-    const localeDirs = new Set();
-    const localeSet = new Set(locales);
-    for (const filePath of filePaths) {
-        const parts = filePath.split(path.sep);
-        // Find directory segments that match the provided locales
-        for (let i = 0; i < parts.length - 1; i++) {
-            const segment = parts[i];
-            if (localeSet.has(segment)) {
-                // Found a locale directory, capture up to and including this segment
-                const localeDir = parts.slice(0, i + 1).join(path.sep);
-                localeDirs.add(localeDir);
-                break;
-            }
-        }
-    }
-    return localeDirs;
-}
-async function getAllFiles(dirPath) {
-    return await fg(path.join(dirPath, '**/*'), {
-        absolute: true,
-        onlyFiles: true,
-    });
-}
-async function getFilesToDelete(dirPath, excludePatterns, currentLocale, cwd) {
-    const allFiles = await getAllFiles(dirPath);
-    const absoluteCwd = path.resolve(cwd);
-    const expandedExcludePatterns = excludePatterns.map((p) => {
-        const resolvedPattern = path.isAbsolute(p) ? p : path.join(absoluteCwd, p);
-        return resolvedPattern
-            .replace(/\[locale\]/g, currentLocale)
-            .replace(/\[locales\]/g, currentLocale);
-    });
-    const filesToKeep = micromatch(allFiles, expandedExcludePatterns, {
-        dot: true,
-    });
-    const filesToKeepSet = new Set(filesToKeep);
-    return allFiles.filter((file) => !filesToKeepSet.has(file));
-}
-/**
- * Clears translated files before writing new translations
- * @param filePaths - Set of translated file paths to clear
- * @param locales - Array of locale codes to match against
- * @param excludePatterns - Optional array of glob patterns to exclude from clearing (supports [locale] and [locales])
- * @param cwd - Current working directory for resolving relative exclude patterns (defaults to process.cwd())
- */
-export async function clearLocaleDirs(filePaths, locales, excludePatterns, cwd = process.cwd()) {
-    // Extract locale directories
-    const localeDirs = extractLocaleDirectories(filePaths, locales);
-    for (const dir of localeDirs) {
-        try {
-            await fs.stat(dir);
-            // Extract locale from directory path
-            const dirParts = dir.split(path.sep);
-            const locale = locales.find((loc) => dirParts.includes(loc));
-            if (!locale) {
-                continue;
-            }
-            if (!excludePatterns?.length) {
-                await fs.rm(dir, { recursive: true, force: true });
-                logger.success(`Cleared locale directory: ${dir}`);
-                continue;
-            }
-            const filesToDelete = await getFilesToDelete(dir, excludePatterns, locale, cwd);
-            // Get all files for count comparison
-            const allFiles = await getAllFiles(dir);
-            for (const file of filesToDelete) {
-                try {
-                    await fs.unlink(file);
-                }
-                catch (error) {
-                    if (error.code !== 'ENOENT') {
-                        logger.warn(`Failed to delete file ${file}: ${error}`);
-                    }
-                }
-            }
-            // Clean up empty directories
-            await cleanupEmptyDirs(dir);
-            const excludedCount = allFiles.length - filesToDelete.length;
-            if (excludedCount > 0) {
-                logger.success(`Cleared locale directory: ${dir} (excluded ${excludedCount} file${excludedCount > 1 ? 's' : ''})`);
-            }
-            else {
-                logger.success(`Cleared locale directory: ${dir}`);
-            }
-        }
-        catch (error) {
-            if (error.code !== 'ENOENT') {
-                logger.warn(`Failed to clear locale directory ${dir}: ${error}`);
-            }
-        }
-    }
-}
-/**
- * Recursively removes empty directories
- * @param dirPath - The directory to clean up
- */
-async function cleanupEmptyDirs(dirPath) {
-    try {
-        const entries = await fs.readdir(dirPath, { withFileTypes: true });
-        // Recursively clean subdirectories first
-        for (const entry of entries) {
-            if (entry.isDirectory()) {
-                await cleanupEmptyDirs(path.join(dirPath, entry.name));
-            }
-        }
-        // Check if directory is now empty
-        const remainingEntries = await fs.readdir(dirPath);
-        if (remainingEntries.length === 0) {
-            await fs.rmdir(dirPath);
-        }
-    }
-    catch (error) {
-        // Ignore errors - directory might not exist or might not be empty
-    }
-}

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

@@ -1,21 +0,0 @@
-export type DownloadedVersionEntry = {
-    fileName?: string;
-    updatedAt?: string;
-    postProcessHash?: string;
-    sourceHash?: string;
-};
-export type DownloadedVersions = {
-    version: number;
-    entries: {
-        [branchId: string]: {
-            [fileId: string]: {
-                [versionId: string]: {
-                    [locale: string]: DownloadedVersionEntry;
-                };
-            };
-        };
-    };
-};
-export declare function getDownloadedVersions(configDirectory: string): DownloadedVersions;
-export declare function saveDownloadedVersions(configDirectory: string, lock: DownloadedVersions): void;
-export declare function ensureNestedObject(obj: any, path: string[]): any;

package/dist/fs/config/downloadedVersions.js

@@ -1,50 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { logger } from '../../console/logger.js';
-// New lock file name, use old name for deletion of legacy lock file
-const GT_LOCK_FILE = 'gt-lock.json';
-const LEGACY_DOWNLOADED_VERSIONS_FILE = 'downloaded-versions.json';
-export function getDownloadedVersions(configDirectory) {
-    try {
-        // Clean up legacy lock files inside the config directory
-        const rootPath = path.join(process.cwd(), GT_LOCK_FILE);
-        const legacyPath = path.join(configDirectory, LEGACY_DOWNLOADED_VERSIONS_FILE);
-        try {
-            if (fs.existsSync(legacyPath)) {
-                fs.unlinkSync(legacyPath);
-            }
-        }
-        catch { }
-        const filepath = fs.existsSync(rootPath) ? rootPath : null;
-        if (!filepath)
-            return { version: 1, entries: {} };
-        const raw = JSON.parse(fs.readFileSync(filepath, 'utf8'));
-        if (raw && typeof raw === 'object' && raw.version && raw.entries) {
-            return raw;
-        }
-        return { version: 1, entries: {} };
-    }
-    catch (error) {
-        logger.error(`An error occurred while getting downloaded versions: ${error}`);
-        return { version: 1, entries: {} };
-    }
-}
-export function saveDownloadedVersions(configDirectory, lock) {
-    try {
-        // Write the lock file to the repo root
-        const filepath = path.join(process.cwd(), GT_LOCK_FILE);
-        fs.mkdirSync(path.dirname(filepath), { recursive: true });
-        fs.writeFileSync(filepath, JSON.stringify(lock, null, 2));
-    }
-    catch (error) {
-        logger.error(`An error occurred while updating ${GT_LOCK_FILE}: ${error}`);
-    }
-}
-export function ensureNestedObject(obj, path) {
-    return path.reduce((current, key, index) => {
-        if (index === path.length - 1)
-            return current;
-        current[key] = current[key] || {};
-        return current[key];
-    }, obj);
-}

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

@@ -1 +0,0 @@
-export declare function loadConfig(filepath: string): Record<string, any>;

package/dist/fs/config/loadConfig.js

@@ -1,9 +0,0 @@
-import fs from 'node:fs';
-export function loadConfig(filepath) {
-    try {
-        return JSON.parse(fs.readFileSync(filepath, 'utf-8'));
-    }
-    catch (error) {
-        return {};
-    }
-}

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

@@ -1,27 +0,0 @@
-import { FilesOptions, ResolvedFiles, TransformFiles, TransformOption } from '../../types/index.js';
-/**
- * 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
- */
-export declare function resolveLocaleFiles(files: ResolvedFiles, locale: string): ResolvedFiles;
-/**
- * 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
- */
-export declare function resolveFiles(files: FilesOptions, locale: string, locales: string[], cwd: string, compositePatterns?: string[]): {
-    resolvedPaths: ResolvedFiles;
-    placeholderPaths: ResolvedFiles;
-    transformPaths: TransformFiles;
-};
-export declare function expandGlobPatterns(cwd: string, includePatterns: string[], excludePatterns: string[], locale: string, locales: string[], transformPatterns?: TransformOption | string | TransformOption[], compositePatterns?: string[]): {
-    resolvedPaths: string[];
-    placeholderPaths: string[];
-};