gtx-cli 2.5.0-alpha.0 → 2.5.0-alpha.2

package/dist/cli/commands/stage.js

@@ -2,7 +2,7 @@ import { logErrorAndExit, logSuccess } from '../../console/logging.js';
 import { noLocalesError, noDefaultLocaleError, noApiKeyError, noProjectIdError, devApiKeyError, invalidConfigurationError, } from '../../console/index.js';
 import { aggregateFiles } from '../../formats/files/translate.js';
 import { aggregateReactTranslations } from '../../translation/stage.js';
-import { sendFiles } from '../../api/sendFiles.js';
+import { stageFiles } from '../../workflow/stage.js';
 import { updateVersions } from '../../fs/config/updateVersions.js';
 import updateConfig from '../../fs/config/updateConfig.js';
 import { hashStringSync } from '../../utils/hash.js';
@@ -62,6 +62,8 @@ export async function handleStage(options, settings, library, stage) {
                 content: JSON.stringify(fileData),
                 fileFormat: 'GTJSON',
                 formatMetadata: fileMetadata,
+                fileId: TEMPLATE_FILE_ID,
+                versionId: hashStringSync(JSON.stringify(fileData)),
             });
         }
     }
@@ -76,19 +78,31 @@ export async function handleStage(options, settings, library, stage) {
         })
             .join('\n');
         logSuccess(`Dry run: No files were sent to General Translation. Found files:\n${fileNames}`);
-        return undefined;
+        return null;
     }
     // Send translations to General Translation
-    let filesTranslationResponse;
+    let fileVersionData;
+    let jobData;
+    let branchData;
     if (allFiles.length > 0) {
-        filesTranslationResponse = await sendFiles(allFiles, options, settings);
+        const { branchData: branchDataResult, enqueueResult } = await stageFiles(allFiles, options, settings);
+        jobData = enqueueResult;
+        branchData = branchDataResult;
+        fileVersionData = Object.fromEntries(allFiles.map((file) => [
+            file.fileId,
+            {
+                fileName: file.fileName,
+                versionId: file.versionId,
+            },
+        ]));
+        // This logic is a little scuffed because stage is async from the API
         if (stage) {
             await updateVersions({
                 configDirectory: settings.configDirectory,
-                versionData: filesTranslationResponse.data,
+                versionData: fileVersionData,
             });
         }
-        const templateData = filesTranslationResponse.data[TEMPLATE_FILE_ID];
+        const templateData = allFiles.find((file) => file.fileId === TEMPLATE_FILE_ID);
         if (templateData?.versionId) {
             await updateConfig({
                 configFilepath: settings.config,
@@ -96,5 +110,9 @@ export async function handleStage(options, settings, library, stage) {
             });
         }
     }
-    return filesTranslationResponse;
+    return {
+        fileVersionData,
+        jobData,
+        branchData,
+    };
 }

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

@@ -1,6 +1,8 @@
-import { SendFilesResult } from '../../api/sendFiles.js';
+import { EnqueueFilesResult } from 'generaltranslation/types';
 import { TranslateFlags } from '../../types/index.js';
 import { Settings } from '../../types/index.js';
-export declare function handleTranslate(options: TranslateFlags, settings: Settings, filesTranslationResponse: SendFilesResult | undefined): Promise<void>;
+import { FileTranslationData } from '../../workflow/download.js';
+import { BranchData } from '../../types/branch.js';
+export declare function handleTranslate(options: TranslateFlags, settings: Settings, fileVersionData: FileTranslationData | undefined, jobData: EnqueueFilesResult | undefined, branchData: BranchData | undefined): Promise<void>;
 export declare function handleDownload(options: TranslateFlags, settings: Settings): Promise<void>;
 export declare function postProcessTranslations(settings: Settings, includeFiles?: Set<string>): Promise<void>;

package/dist/cli/commands/translate.js

@@ -1,4 +1,4 @@
-import { checkFileTranslations } from '../../api/checkFileTranslations.js';
+import { downloadTranslations, } from '../../workflow/download.js';
 import { createFileMapping } from '../../formats/files/fileMapping.js';
 import { logError } from '../../console/logging.js';
 import { getStagedVersions } from '../../fs/config/updateVersions.js';
@@ -9,13 +9,12 @@ import processAnchorIds from '../../utils/processAnchorIds.js';
 import { noFilesError, noVersionIdError } from '../../console/index.js';
 import localizeStaticImports from '../../utils/localizeStaticImports.js';
 // Downloads translations that were completed
-export async function handleTranslate(options, settings, filesTranslationResponse) {
-    if (filesTranslationResponse) {
+export async function handleTranslate(options, settings, fileVersionData, jobData, branchData) {
+    if (fileVersionData) {
         const { resolvedPaths, placeholderPaths, transformPaths } = settings.files;
         const fileMapping = createFileMapping(resolvedPaths, placeholderPaths, transformPaths, settings.locales, settings.defaultLocale);
-        const { data } = filesTranslationResponse;
         // Check for remaining translations
-        await checkFileTranslations(data, settings.locales, options.timeout, (sourcePath, locale) => fileMapping[locale]?.[sourcePath] ?? null, settings, options.force, options.forceDownload);
+        await downloadTranslations(fileVersionData, jobData, branchData, settings.locales, options.timeout, (sourcePath, locale) => fileMapping[locale]?.[sourcePath] ?? null, settings, options.force, options.forceDownload);
     }
 }
 // Downloads translations that were originally staged
@@ -33,7 +32,7 @@ export async function handleDownload(options, settings) {
     const fileMapping = createFileMapping(resolvedPaths, placeholderPaths, transformPaths, settings.locales, settings.defaultLocale);
     const stagedVersionData = await getStagedVersions(settings.configDirectory);
     // Check for remaining translations
-    await checkFileTranslations(stagedVersionData, settings.locales, options.timeout, (sourcePath, locale) => fileMapping[locale][sourcePath] ?? null, settings, false, // force is not applicable for downloading staged translations
+    await downloadTranslations(stagedVersionData, undefined, undefined, settings.locales, options.timeout, (sourcePath, locale) => fileMapping[locale][sourcePath] ?? null, settings, false, // force is not applicable for downloading staged translations
     options.forceDownload);
 }
 export async function postProcessTranslations(settings, includeFiles) {

package/dist/cli/flags.js

@@ -28,7 +28,10 @@ export function attachTranslateFlags(command) {
         .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)
         .option('--force', 'Force a retranslation, invalidating all existing cached translations if they exist.', false)
         .option('--force-download', 'Force download and overwrite local files, bypassing gt-lock.json checks.', false)
-        .option('--experimental-clear-locale-dirs', 'Clear locale directories before downloading new translations', false);
+        .option('--experimental-clear-locale-dirs', 'Clear locale directories before downloading new translations', false)
+        .option('--branch <branch>', 'Specify a custom branch to use for translations')
+        .option('--disable-branch-detection', 'Disable additional branch detection and optimizations and use the manually specified branch', false)
+        .option('--enable-branching', 'Enable branching for the project', false); // disabled by default for now
     return command;
 }
 export function attachAdditionalReactTranslateFlags(command) {

package/dist/config/generateSettings.js

@@ -159,6 +159,16 @@ export async function generateSettings(flags, cwd = process.cwd()) {
     mergedOptions.parsingOptions = mergedOptions.parsingOptions || {};
     mergedOptions.parsingOptions.conditionNames = mergedOptions.parsingOptions
         .conditionNames || ['browser', 'module', 'import', 'require', 'default'];
+    // Add branch options if not provided
+    const branchOptions = mergedOptions.branchOptions || {};
+    branchOptions.enabled = flags.enableBranching ?? false;
+    branchOptions.currentBranch =
+        flags.branch ?? gtConfig.branchOptions?.currentBranch ?? undefined;
+    branchOptions.autoDetectBranches = flags.disableBranchDetection
+        ? false
+        : true;
+    branchOptions.remoteName = gtConfig.branchOptions?.remoteName ?? 'origin';
+    mergedOptions.branchOptions = branchOptions;
     // if there's no existing config file, creates one
     // does not include the API key to avoid exposing it
     if (!fs.existsSync(mergedOptions.config)) {

package/dist/console/colors.d.ts

@@ -1,6 +1,5 @@
 export declare function colorizeFilepath(filepath: string): string;
 export declare function colorizeComponent(component: string): string;
-export declare function colorizeFunctionName(functionName: string): string;
 export declare function colorizeIdString(id: string): string;
 export declare function colorizeContent(content: string): string;
 export declare function colorizeLine(line: string): string;

package/dist/console/colors.js

@@ -5,9 +5,6 @@ export function colorizeFilepath(filepath) {
 export function colorizeComponent(component) {
     return chalk.yellow(component);
 }
-export function colorizeFunctionName(functionName) {
-    return chalk.yellow(functionName);
-}
 export function colorizeIdString(id) {
     return chalk.yellow(id);
 }

package/dist/console/index.d.ts

@@ -1,7 +1,5 @@
 export declare const warnApiKeyInConfigSync: (optionsFilepath: string) => string;
 export declare const warnVariablePropSync: (file: string, attrName: string, value: string, location?: string) => string;
-export declare const warnInvalidReturnSync: (file: string, functionName: string, expression: string, location?: string) => string;
-export declare const warnMissingReturnSync: (file: string, functionName: string, location?: string) => string;
 export declare const warnHasUnwrappedExpressionSync: (file: string, unwrappedExpressions: string[], id?: string, location?: string) => string;
 export declare const warnNestedTComponent: (file: string, location?: string) => string;
 export declare const warnNonStaticExpressionSync: (file: string, attrName: string, value: string, location?: string) => string;
@@ -12,10 +10,6 @@ export declare const warnAsyncUseGT: (file: string, location?: string) => string
 export declare const warnSyncGetGT: (file: string, location?: string) => string;
 export declare const warnTernarySync: (file: string, location?: string) => string;
 export declare const withLocation: (file: string, message: string, location?: string) => string;
-export declare const warnInvalidStaticChildSync: (file: string, location?: string) => string;
-export declare const warnFunctionNotFoundSync: (file: string, functionName: string, location?: string) => string;
-export declare const warnDuplicateFunctionDefinitionSync: (file: string, functionName: string, location?: string) => string;
-export declare const warnInvalidStaticInitSync: (file: string, functionName: string, location?: string) => string;
 export declare const noLocalesError = "No locales found! Please provide a list of locales to translate to, or specify them in your gt.config.json file.";
 export declare const noDefaultLocaleError = "No default locale found! Please provide a default locale, or specify it in your gt.config.json file.";
 export declare const noFilesError = "Incorrect or missing files configuration! Please make sure your files are configured correctly in your gt.config.json file.";

package/dist/console/index.js

@@ -1,13 +1,7 @@
-import { colorizeFilepath, colorizeComponent, colorizeIdString, colorizeContent, colorizeLine, colorizeFunctionName, } from './colors.js';
-const withWillErrorInNextVersion = (message) => `${message} (This will become an error in the next major version of the CLI.)`;
-// Static function related errors
-const withStaticError = (message) => `<Static> rules violation: ${message}`;
+import { colorizeFilepath, colorizeComponent, colorizeIdString, colorizeContent, colorizeLine, } from './colors.js';
 // Synchronous wrappers for backward compatibility
 export const warnApiKeyInConfigSync = (optionsFilepath) => `${colorizeFilepath(optionsFilepath)}: Your API key is exposed! Please remove it from the file and include it as an environment variable.`;
 export const warnVariablePropSync = (file, attrName, value, location) => withLocation(file, `${colorizeComponent('<T>')} component has dynamic attribute ${colorizeIdString(attrName)} with value: ${colorizeContent(value)}. Change ${colorizeIdString(attrName)} to ensure this content is translated.`, location);
-export const warnInvalidReturnSync = (file, functionName, expression, location) => withLocation(file, withStaticError(`Function ${colorizeFunctionName(functionName)} does not return a static expression. ${colorizeFunctionName(functionName)} must return either (1) a static string literal, (2) another static function invocation, (3) static JSX content, or (4) a ternary expression. Instead got:\n${colorizeContent(expression)}`), location);
-// TODO: this is temporary until we handle implicit returns
-export const warnMissingReturnSync = (file, functionName, location) => withLocation(file, `Function ${colorizeFunctionName(functionName)} is wrapped in ${colorizeComponent('<Static>')} tags but does have an explicit return statement. Static functions must have an explicit return statment.`, location);
 export const warnHasUnwrappedExpressionSync = (file, unwrappedExpressions, id, location) => withLocation(file, `${colorizeComponent('<T>')} component${id ? ` with id ${colorizeIdString(id)}` : ''} has children that could change at runtime. Use a variable component like ${colorizeComponent('<Var>')} to ensure this content is translated.\n${colorizeContent(unwrappedExpressions.join('\n'))}`, location);
 export const warnNestedTComponent = (file, location) => withLocation(file, `Found nested <T> component. <T> components cannot be directly nested.`, location);
 export const warnNonStaticExpressionSync = (file, attrName, value, location) => withLocation(file, `Found non-static expression for attribute ${colorizeIdString(attrName)}: ${colorizeContent(value)}. Change "${colorizeIdString(attrName)}" to ensure this content is translated.`, location);
@@ -18,12 +12,7 @@ export const warnAsyncUseGT = (file, location) => withLocation(file, `Found useG
 export const warnSyncGetGT = (file, location) => withLocation(file, `Found getGT() in a synchronous function. Use useGT() instead, or make the function async.`, location);
 export const warnTernarySync = (file, location) => withLocation(file, 'Found ternary expression. A Branch component may be more appropriate here.', location);
 export const withLocation = (file, message, location) => `${colorizeFilepath(file)}${location ? ` (${colorizeLine(location)})` : ''}: ${message}`;
-export const warnInvalidStaticChildSync = (file, location) => withLocation(file, 'Found invalid <Static> invocation. Children must be an expression container with a function invocation. Callee must be a single identifier. (Example: <T> <Static> {getSubject()} </Static> </T>)', location);
-export const warnFunctionNotFoundSync = (file, functionName, location) => withLocation(file, `Function ${colorizeFunctionName(functionName)} definition could not be resolved. This might affect translation resolution for this ${colorizeComponent('<T>')} component.`, location);
-export const warnDuplicateFunctionDefinitionSync = (file, functionName, location) => withLocation(file, `Function ${colorizeFunctionName(functionName)} is defined multiple times. Only the first definition will be used.`, location);
-export const warnInvalidStaticInitSync = (file, functionName, location) => withLocation(file, withStaticError(`The definition for ${colorizeFunctionName(functionName)} could not be resolved. When using arrow syntax to define a static function, the right hand side or the assignment MUST only contain the arrow function itself and no other expressions.
-Example: ${colorizeContent(`const ${colorizeFunctionName(functionName)} = () => { ... }`)}
-Invalid: ${colorizeContent(`const ${colorizeFunctionName(functionName)} = [() => { ... }][0]`)}`), location);
+const withWillErrorInNextVersion = (message) => `${message} (This will become an error in the next major version of the CLI.)`;
 // Re-export error messages
 export const noLocalesError = `No locales found! Please provide a list of locales to translate to, or specify them in your gt.config.json file.`;
 export const noDefaultLocaleError = `No default locale found! Please provide a default locale, or specify it in your gt.config.json file.`;

package/dist/console/logging.d.ts

@@ -15,7 +15,7 @@ export declare function displayCreatedConfigFile(configFilepath: string): void;
 export declare function displayUpdatedConfigFile(configFilepath: string): void;
 export declare function displayUpdatedVersionsFile(versionFilepath: string): void;
 export declare function createSpinner(indicator?: 'dots' | 'timer'): import("@clack/prompts").SpinnerResult;
-export declare function createOraSpinner(indicator?: 'dots' | 'circleHalves'): Promise<import("ora").Ora>;
+export declare function createProgressBar(total: number): import("@clack/prompts").ProgressResult;
 export declare function promptText({ message, defaultValue, validate, }: {
     message: string;
     defaultValue?: string;

package/dist/console/logging.js

@@ -1,4 +1,4 @@
-import { log, spinner, intro, outro, text, select, confirm, isCancel, cancel, multiselect, } from '@clack/prompts';
+import { log, spinner, intro, outro, text, select, confirm, isCancel, cancel, multiselect, progress, } from '@clack/prompts';
 import chalk from 'chalk';
 import { getCLIVersion } from '../utils/packageJson.js';
 // Basic logging functions
@@ -81,9 +81,8 @@ export function createSpinner(indicator = 'timer') {
     return spinner({ indicator });
 }
 // Spinner functionality
-export async function createOraSpinner(indicator = 'circleHalves') {
-    const ora = await import('ora');
-    return ora.default({ spinner: indicator });
+export function createProgressBar(total) {
+    return progress({ max: total });
 }
 // Input prompts
 export async function promptText({ message, defaultValue, validate, }) {

package/dist/formats/files/translate.d.ts

@@ -1,4 +1,4 @@
 import { Settings } from '../../types/index.js';
-import { FileToTranslate } from '../../types/data.js';
+import type { FileToUpload } from '../../types/data.js';
 export declare const SUPPORTED_DATA_FORMATS: string[];
-export declare function aggregateFiles(settings: Settings): Promise<FileToTranslate[]>;
+export declare function aggregateFiles(settings: Settings): Promise<FileToUpload[]>;

package/dist/formats/files/translate.js

@@ -4,8 +4,10 @@ import { SUPPORTED_FILE_EXTENSIONS } from './supportedFiles.js';
 import sanitizeFileContent from '../../utils/sanitizeFileContent.js';
 import { parseJson } from '../json/parseJson.js';
 import parseYaml from '../yaml/parseYaml.js';
+import YAML from 'yaml';
 import { determineLibrary } from '../../fs/determineFramework.js';
 import { isValidMdx } from '../../utils/validateMdx.js';
+import { hashStringSync } from '../../utils/hash.js';
 export const SUPPORTED_DATA_FORMATS = ['JSX', 'ICU', 'I18NEXT'];
 export async function aggregateFiles(settings) {
     // Aggregate all files to translate
@@ -39,8 +41,18 @@ export async function aggregateFiles(settings) {
             .map((filePath) => {
             const content = readFile(filePath);
             const relativePath = getRelative(filePath);
+            // Pre-validate JSON parseability
+            try {
+                JSON.parse(content);
+            }
+            catch (e) {
+                logWarning(`Skipping ${relativePath}: JSON file is not parsable`);
+                return null;
+            }
             const parsedJson = parseJson(content, filePath, settings.options || {}, settings.defaultLocale);
             return {
+                fileId: hashStringSync(relativePath),
+                versionId: hashStringSync(parsedJson),
                 content: parsedJson,
                 fileName: relativePath,
                 fileFormat: 'JSON',
@@ -48,13 +60,15 @@ export async function aggregateFiles(settings) {
             };
         })
             .filter((file) => {
-            if (!file || typeof file.content !== 'string' || !file.content.trim()) {
-                logWarning(`Skipping ${file?.fileName ?? 'unknown'}: JSON file is empty`);
+            if (!file)
+                return false;
+            if (typeof file.content !== 'string' || !file.content.trim()) {
+                logWarning(`Skipping ${file.fileName}: JSON file is empty`);
                 return false;
             }
             return true;
         });
-        allFiles.push(...jsonFiles);
+        allFiles.push(...jsonFiles.filter((file) => file !== null));
     }
     // Process YAML files
     if (filePaths.yaml) {
@@ -62,11 +76,21 @@ export async function aggregateFiles(settings) {
             .map((filePath) => {
             const content = readFile(filePath);
             const relativePath = getRelative(filePath);
+            // Pre-validate YAML parseability
+            try {
+                YAML.parse(content);
+            }
+            catch (e) {
+                logWarning(`Skipping ${relativePath}: YAML file is not parsable`);
+                return null;
+            }
             const { content: parsedYaml, fileFormat } = parseYaml(content, filePath, settings.options || {});
             return {
                 content: parsedYaml,
                 fileName: relativePath,
                 fileFormat,
+                fileId: hashStringSync(relativePath),
+                versionId: hashStringSync(parsedYaml),
             };
         })
             .filter((file) => {
@@ -76,7 +100,7 @@ export async function aggregateFiles(settings) {
             }
             return true;
         });
-        allFiles.push(...yamlFiles);
+        allFiles.push(...yamlFiles.filter((file) => file !== null));
     }
     for (const fileType of SUPPORTED_FILE_EXTENSIONS) {
         if (fileType === 'json' || fileType === 'yaml')
@@ -98,6 +122,8 @@ export async function aggregateFiles(settings) {
                     content: sanitizedContent,
                     fileName: relativePath,
                     fileFormat: fileType.toUpperCase(),
+                    fileId: hashStringSync(relativePath),
+                    versionId: hashStringSync(content),
                 };
             })
                 .filter((file) => {
@@ -109,7 +135,7 @@ export async function aggregateFiles(settings) {
                 }
                 return true;
             });
-            allFiles.push(...files);
+            allFiles.push(...files.filter((file) => file !== null));
         }
     }
     if (allFiles.length === 0 && !settings.publish) {

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

@@ -1,12 +1,19 @@
 export type DownloadedVersionEntry = {
-    versionId: string;
-    fileId?: string;
     fileName?: string;
     updatedAt?: string;
 };
 export type DownloadedVersions = {
     version: number;
-    entries: Record<string, DownloadedVersionEntry>;
+    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

@@ -40,3 +40,11 @@ export function saveDownloadedVersions(configDirectory, lock) {
         logError(`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/updateVersions.d.ts

@@ -1,4 +1,5 @@
-type StagedVersionData = Record<string, {
+type StagedVersionData = Record<string, // fileId
+{
     fileName: string;
     versionId: string;
 }>;

package/dist/git/branches.d.ts

@@ -0,0 +1,7 @@
+export declare function getCurrentBranch(remoteName: string): Promise<{
+    currentBranchName: string;
+    defaultBranch: boolean;
+    defaultBranchName: string;
+} | null>;
+export declare function getIncomingBranches(remoteName: string): Promise<string[]>;
+export declare function getCheckedOutBranches(remoteName: string): Promise<string[]>;

package/dist/git/branches.js

@@ -0,0 +1,88 @@
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(execFile);
+const MAX_BRANCHES = 5;
+export async function getCurrentBranch(remoteName) {
+    try {
+        const { stdout } = await execAsync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
+            encoding: 'utf8',
+            windowsHide: true,
+        });
+        const currentBranchName = stdout.trim();
+        // Get the default branch (usually main or master)
+        const { stdout: defaultBranchRef } = await execAsync('git', ['symbolic-ref', `refs/remotes/${remoteName}/HEAD`], { encoding: 'utf8', windowsHide: true });
+        const defaultBranchName = defaultBranchRef
+            .trim()
+            .replace(`refs/remotes/${remoteName}/`, '');
+        const defaultBranch = currentBranchName === defaultBranchName;
+        return { currentBranchName, defaultBranch, defaultBranchName };
+    }
+    catch {
+        return null;
+    }
+}
+export async function getIncomingBranches(remoteName) {
+    try {
+        // Get merge commits into the current branch
+        const { stdout } = await execAsync('git', [
+            'log',
+            '--merges',
+            '--first-parent',
+            '--pretty=format:%s',
+            `-${MAX_BRANCHES}`,
+        ], {
+            encoding: 'utf8',
+            windowsHide: true,
+        });
+        if (!stdout.trim()) {
+            return [];
+        }
+        const branches = [];
+        const lines = stdout.trim().split('\n');
+        for (const line of lines) {
+            // Parse merge commit messages:
+            // - "Merge branch 'feature-name'" or "Merge branch 'feature-name' into main"
+            // - "Merge pull request #123 from user/branch-name"
+            const branchMatch = line.match(/Merge branch '([^']+)'/);
+            const prMatch = line.match(/Merge pull request #\d+ from [^/]+\/(.+)/);
+            if (branchMatch && branchMatch[1]) {
+                branches.push(branchMatch[1]);
+            }
+            else if (prMatch && prMatch[1]) {
+                branches.push(prMatch[1]);
+            }
+        }
+        return branches.slice(0, MAX_BRANCHES);
+    }
+    catch {
+        // If log fails or no merges found, return empty array
+        return [];
+    }
+}
+export async function getCheckedOutBranches(remoteName) {
+    try {
+        // Get current branch
+        const currentBranchResult = await getCurrentBranch(remoteName);
+        if (!currentBranchResult) {
+            return [];
+        }
+        // If we're already on the default branch, return empty
+        if (currentBranchResult.defaultBranch) {
+            return [];
+        }
+        // Check if there's a merge-base (common ancestor) between default branch and current
+        // This means the branch was at some point checked out from the default branch
+        try {
+            await execAsync('git', ['merge-base', currentBranchResult.defaultBranchName, 'HEAD'], { encoding: 'utf8', windowsHide: true });
+            // If merge-base exists, the branch shares history with default branch
+            return [currentBranchResult.defaultBranchName];
+        }
+        catch {
+            // No common ancestor found
+            return [];
+        }
+    }
+    catch {
+        return [];
+    }
+}

package/dist/react/{jsx/utils/jsxParsing → data-_gt}/addGTIdentifierToSyntaxTree.d.ts

@@ -1,9 +1,8 @@
 import { JsxChildren } from 'generaltranslation/types';
-import { MultipliedTreeNode } from './types.js';
 /**
  * Add GT Identifier and minify the tree (recreates addGTIdentifier and writeChildrenAsObjects)
  * @param tree - The tree to add GT identifiers to
  * @param startingIndex - The starting index for GT IDs
  * @returns The tree with GT identifiers added
  */
-export default function addGTIdentifierToSyntaxTree(tree: MultipliedTreeNode, startingIndex?: number): JsxChildren;
+export default function addGTIdentifierToSyntaxTree(tree: any, startingIndex?: number): JsxChildren;

package/dist/react/{jsx/utils/jsxParsing → data-_gt}/addGTIdentifierToSyntaxTree.js

@@ -1,5 +1,5 @@
 import { HTML_CONTENT_PROPS, } from 'generaltranslation/types';
-import { defaultVariableNames, getVariableName, minifyVariableType, } from '../../../utils/getVariableName.js';
+import { defaultVariableNames, getVariableName, minifyVariableType, } from '../utils/getVariableName.js';
 import { isAcceptedPluralForm } from 'generaltranslation/internal';
 /**
  * Construct the data-_gt prop
@@ -55,10 +55,6 @@ function constructGTProp(type, props, id) {
  * @returns The tree with GT identifiers added
  */
 export default function addGTIdentifierToSyntaxTree(tree, startingIndex = 0) {
-    // Edge case: boolean or null, just return the tree
-    if (typeof tree === 'boolean' || tree === null) {
-        return tree;
-    }
     // Object to keep track of the current index for GT IDs
     const indexObject = { index: startingIndex };
     /**
@@ -87,23 +83,12 @@ export default function addGTIdentifierToSyntaxTree(tree, startingIndex = 0) {
                 };
             }
             // Construct the data-_gt prop
-            const generaltranslation = constructGTProp(type, (props || {}), indexObject.index);
-            // Save current index and recurse
-            const currentIndex = indexObject.index;
-            const children = handleChildren(props?.children === undefined ? null : props?.children);
-            // Enforce boolean rendering behavior
-            // <T>{true}</T> -> true <- this is a boolean value, not a string
-            // <T>{false}</T> -> nothing
-            let includeChildren = true;
-            if (typeof children === 'boolean') {
-                // So, technically JsxChildren do include boolean values, but the type is incorrect
-                includeChildren = children !== false;
-            }
+            const generaltranslation = constructGTProp(type, props, indexObject.index);
             // Return the result
             return {
-                t: type || `C${currentIndex}`,
-                i: currentIndex,
-                ...(includeChildren && { c: children }),
+                t: type || `C${indexObject.index}`,
+                i: indexObject.index,
+                c: handleChildren(props.children),
                 ...(generaltranslation && { d: generaltranslation }),
             };
         }
@@ -119,16 +104,7 @@ export default function addGTIdentifierToSyntaxTree(tree, startingIndex = 0) {
      */
     const handleChildren = (children) => {
         return Array.isArray(children)
-            ? children.map(handleSingleChild).filter((child) => {
-                // Enforce boolean rendering behavior
-                // <T>{true}{false}{null}</T> -> []
-                if (typeof child === 'boolean' ||
-                    child === null ||
-                    child === undefined) {
-                    return false;
-                }
-                return true;
-            })
+            ? children.map(handleSingleChild)
             : handleSingleChild(children);
     };
     return handleChildren(tree);

package/dist/react/jsx/evaluateJsx.d.ts

@@ -5,14 +5,15 @@ import * as t from '@babel/types';
  * @returns Whether the node is meaningful
  */
 export declare function isMeaningful(node: t.Node): boolean;
-export declare function isStaticExpression(expr: t.Expression | t.JSXEmptyExpression, jsxStatic?: false): {
+/**
+ * Checks if an expression is static (does not contain any variables which could change at runtime).
+ * @param expr - The expression to check
+ * @returns An object containing the result of the static check
+ */
+export declare function isStaticExpression(expr: t.Expression | t.JSXEmptyExpression): {
     isStatic: boolean;
     value?: string;
 };
-export declare function isStaticExpression(expr: t.Expression | t.JSXEmptyExpression, jsxStatic?: true): {
-    isStatic: boolean;
-    value?: string | boolean | null;
-};
 export declare function isStaticValue(expr: t.Expression | t.JSXEmptyExpression): boolean;
 export declare function isValidIcu(string: string): {
     isValid: boolean;