gt 2.14.5 → 2.14.6

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # gtx-cli
 
+## 2.14.6
+
+### Patch Changes
+
+- [#1173](https://github.com/generaltranslation/gt/pull/1173) [`6b0b56b`](https://github.com/generaltranslation/gt/commit/6b0b56b2253e389913fe67eb19f0ba6ebf2c7a53) Thanks [@ErnestM1234](https://github.com/ErnestM1234)! - add context derivation
+
+- Updated dependencies [[`6b0b56b`](https://github.com/generaltranslation/gt/commit/6b0b56b2253e389913fe67eb19f0ba6ebf2c7a53)]:
+  - @generaltranslation/python-extractor@0.2.7
+
 ## 2.14.5
 
 ### Patch Changes

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const PACKAGE_VERSION = "2.14.5";
+export declare const PACKAGE_VERSION = "2.14.6";

package/dist/generated/version.js

@@ -1,2 +1,2 @@
 // This file is auto-generated. Do not edit manually.
-export const PACKAGE_VERSION = '2.14.5';
+export const PACKAGE_VERSION = '2.14.6';

package/dist/react/jsx/utils/jsxParsing/parseJsx.js

@@ -24,6 +24,8 @@ import { ensureTAndVarImported, autoInsertJsxComponents, } from './autoInsertion
 import path from 'node:path';
 import { extractSourceCode } from '../extractSourceCode.js';
 import { SURROUNDING_LINE_COUNT } from '../../../../utils/constants.js';
+import { handleDerivation } from '../stringParsing/derivation/handleDerivation.js';
+import { nodeToStrings } from '../parseString.js';
 // Handle CommonJS/ESM interop
 const traverse = traverseModule.default || traverseModule;
 // TODO: currently we cover VariableDeclaration and FunctionDeclaration nodes, but are there others we should cover as well?
@@ -562,19 +564,52 @@ function parseJSXElement({ node, originalName, scopeNode, updates, config, state
     }
     // Create a temporary unique flag for derivable content
     const temporaryDeriveId = `derive-temp-id-${randomUUID()}`;
+    // Resolve derive context variants if present
+    let contextVariants;
+    if (metadata._contextDeriveExpr) {
+        const contextExpr = metadata._contextDeriveExpr;
+        delete metadata._contextDeriveExpr;
+        const contextNode = handleDerivation({
+            expr: contextExpr,
+            tPath: scopeNode,
+            file: config.file,
+            parsingOptions: config.parsingOptions,
+            errors: componentErrors,
+            warnings: componentWarnings,
+        });
+        if (contextNode) {
+            contextVariants = nodeToStrings(contextNode);
+        }
+    }
     // <T> is valid here
     for (const minifiedTree of minifiedTress) {
         // Clean the tree by removing null 'c' fields from JsxElements
         const cleanedTree = removeNullChildrenFields(minifiedTree);
-        updates.push({
-            dataFormat: 'JSX',
-            source: cleanedTree,
-            metadata: {
-                // eslint-disable-next-line no-undef
-                ...structuredClone(metadata),
-                ...(derivableTracker.isDerivable && { staticId: temporaryDeriveId }),
-            },
-        });
+        if (contextVariants) {
+            for (const context of contextVariants) {
+                updates.push({
+                    dataFormat: 'JSX',
+                    source: cleanedTree,
+                    metadata: {
+                        // eslint-disable-next-line no-undef
+                        ...structuredClone(metadata),
+                        context,
+                        staticId: temporaryDeriveId,
+                    },
+                });
+            }
+        }
+        else {
+            updates.push({
+                dataFormat: 'JSX',
+                source: cleanedTree,
+                metadata: {
+                    // eslint-disable-next-line no-undef
+                    ...structuredClone(metadata),
+                    ...(derivableTracker.isDerivable && { staticId: temporaryDeriveId }),
+                },
+            });
+        }
     }
 }
 function resolveDeriveFunctionInvocationFromBinding({ calleeBinding, callee, config, state, output, }) {

package/dist/react/jsx/utils/jsxParsing/parseTProps.js

@@ -7,6 +7,7 @@ import { mapAttributeName } from '../mapAttributeName.js';
 import { isStaticExpression } from '../../evaluateJsx.js';
 import { warnInvalidMaxCharsSync, warnVariablePropSync, } from '../../../../console/index.js';
 import { isNumberLiteral } from '../isNumberLiteral.js';
+import { containsDeriveCall } from '../stringParsing/derivation/containsDeriveCall.js';
 // Parse the props of a <T> component
 export function parseTProps({ openingElement, metadata, componentErrors, file, }) {
     openingElement.attributes.forEach((attr) => {
@@ -28,7 +29,14 @@ export function parseTProps({ openingElement, metadata, componentErrors, file, }
                 if (GT_ATTRIBUTES.includes(attrName)) {
                     const staticAnalysis = isStaticExpression(expr);
                     if (!staticAnalysis.isStatic) {
-                        componentErrors.push(warnVariablePropSync(file, attrName, code, `${expr.loc?.start?.line}:${expr.loc?.start?.column}`));
+                        if (mapAttributeName(attrName) === 'context' &&
+                            t.isExpression(expr) &&
+                            containsDeriveCall(expr)) {
+                            metadata._contextDeriveExpr = expr;
+                        }
+                        else {
+                            componentErrors.push(warnVariablePropSync(file, attrName, code, `${expr.loc?.start?.line}:${expr.loc?.start?.column}`));
+                        }
                     }
                     // Use the derived value if available
                     if (staticAnalysis.isStatic && staticAnalysis.value !== undefined) {

package/dist/react/jsx/utils/stringParsing/derivation/containsDeriveCall.d.ts

@@ -0,0 +1,7 @@
+import * as t from '@babel/types';
+/**
+ * Lightweight name-based check for whether an expression tree contains
+ * a derive()/declareStatic() call. Does NOT validate imports or scope —
+ * used as a fast gate before full resolution via handleDerivation().
+ */
+export declare function containsDeriveCall(expr: t.Expression): boolean;

package/dist/react/jsx/utils/stringParsing/derivation/containsDeriveCall.js

@@ -0,0 +1,26 @@
+import * as t from '@babel/types';
+import { GT_DERIVE_STRING_FUNCTIONS } from '../../constants.js';
+/**
+ * Lightweight name-based check for whether an expression tree contains
+ * a derive()/declareStatic() call. Does NOT validate imports or scope —
+ * used as a fast gate before full resolution via handleDerivation().
+ */
+export function containsDeriveCall(expr) {
+    if (t.isCallExpression(expr) && t.isIdentifier(expr.callee)) {
+        return GT_DERIVE_STRING_FUNCTIONS.includes(expr.callee.name);
+    }
+    if (t.isBinaryExpression(expr)) {
+        return ((t.isExpression(expr.left) && containsDeriveCall(expr.left)) ||
+            (t.isExpression(expr.right) && containsDeriveCall(expr.right)));
+    }
+    if (t.isTemplateLiteral(expr)) {
+        return expr.expressions.some((e) => t.isExpression(e) && containsDeriveCall(e));
+    }
+    if (t.isConditionalExpression(expr)) {
+        return (containsDeriveCall(expr.consequent) || containsDeriveCall(expr.alternate));
+    }
+    if (t.isParenthesizedExpression(expr)) {
+        return containsDeriveCall(expr.expression);
+    }
+    return false;
+}

package/dist/react/jsx/utils/stringParsing/derivation/handleDerivation.js

@@ -262,8 +262,24 @@ function getDeriveVariants({ call, tPath, file, parsingOptions, errors, warnings
         // Resolve the inner call's possible string outcomes
         return resolveCallStringVariants(arg.argument, tPath, file, parsingOptions, errors, warnings);
     }
-    // Resolve the inner call's possible string outcomes
-    return resolveCallStringVariants(arg, tPath, file, parsingOptions, errors, warnings);
+    // Handle call expression: derive(time())
+    if (t.isCallExpression(arg)) {
+        return resolveCallStringVariants(arg, tPath, file, parsingOptions, errors, warnings);
+    }
+    // Handle other expressions (ternary, string literal, etc.) by recursing into handleDerivation
+    const node = handleDerivation({
+        expr: arg,
+        tPath,
+        file,
+        parsingOptions,
+        errors,
+        warnings,
+        skipDeriveInvocation: true,
+    });
+    if (node) {
+        return nodeToStrings(node);
+    }
+    return null;
 }
 function resolveCallStringVariants(expression, tPath, file, parsingOptions, errors, warnings) {
     // Handle function identifier calls: derive(time())

package/dist/react/jsx/utils/stringParsing/derivation/index.d.ts

@@ -14,7 +14,7 @@ import { ParsingOutput } from '../types.js';
  * @param output - Parsing output collectors
  * @param enableRuntimeInterpolation - For template macros, enables runtime interpolation for non-derive calls
  */
-export declare function deriveExpression({ tPath, expr, metadata, config, output, index, enableRuntimeInterpolation, }: {
+export declare function deriveExpression({ tPath, expr, metadata, config, output, index, enableRuntimeInterpolation, contextVariants, }: {
     tPath: NodePath;
     expr: t.Expression;
     metadata: InlineMetadata;
@@ -22,4 +22,5 @@ export declare function deriveExpression({ tPath, expr, metadata, config, output
     output: ParsingOutput;
     index?: number;
     enableRuntimeInterpolation?: boolean;
+    contextVariants?: string[];
 }): void;

package/dist/react/jsx/utils/stringParsing/derivation/index.js

@@ -19,7 +19,7 @@ const generate = generateModule.default || generateModule;
  * @param output - Parsing output collectors
  * @param enableRuntimeInterpolation - For template macros, enables runtime interpolation for non-derive calls
  */
-export function deriveExpression({ tPath, expr, metadata, config, output, index, enableRuntimeInterpolation = false, }) {
+export function deriveExpression({ tPath, expr, metadata, config, output, index, enableRuntimeInterpolation = false, contextVariants, }) {
     // parse derivable expression
     const stringNode = handleDerivation({
         expr,
@@ -50,16 +50,21 @@ export function deriveExpression({ tPath, expr, metadata, config, output, index,
         }
     }
     const temporaryDeriveId = `derive-temp-id-${randomUUID()}`;
+    const contexts = contextVariants ?? [metadata.context];
     for (const string of strings) {
-        output.updates.push({
-            dataFormat: (metadata.format || 'ICU'),
-            source: string,
-            metadata: {
-                ...metadata,
-                // Add the index if an id and index is provided (for handling when registering an array of strings)
-                ...(metadata.id && index != null && { id: `${metadata.id}.${index}` }),
-                staticId: temporaryDeriveId,
-            },
-        });
+        for (const context of contexts) {
+            output.updates.push({
+                dataFormat: (metadata.format || 'ICU'),
+                source: string,
+                metadata: {
+                    ...metadata,
+                    ...(context != null && { context }),
+                    // Add the index if an id and index is provided (for handling when registering an array of strings)
+                    ...(metadata.id &&
+                        index != null && { id: `${metadata.id}.${index}` }),
+                    staticId: temporaryDeriveId,
+                },
+            });
+        }
     }
 }

package/dist/react/jsx/utils/stringParsing/processTranslationCall/extractStringEntryMetadata.d.ts

@@ -13,6 +13,7 @@ export type InlineMetadata = {
     format?: string;
     filePaths?: string[];
     sourceCode?: Record<string, SourceCode[]>;
+    contextDeriveExpr?: t.Expression;
 };
 /**
  * Extracts inline metadata from a string entry

package/dist/react/jsx/utils/stringParsing/processTranslationCall/extractStringEntryMetadata.js

@@ -4,6 +4,7 @@ import { warnInvalidMaxCharsSync } from '../../../../../console/index.js';
 import { warnInvalidFormatSync } from '../../../../../console/index.js';
 import { warnNonStaticExpressionSync } from '../../../../../console/index.js';
 import { GT_ATTRIBUTES_WITH_SUGAR } from '../../constants.js';
+import { containsDeriveCall } from '../derivation/containsDeriveCall.js';
 import generateModule from '@babel/generator';
 import { mapAttributeName } from '../../mapAttributeName.js';
 import pathModule from 'node:path';
@@ -59,6 +60,7 @@ export function extractStringEntryMetadata({ options, output, config, nodeLoc, s
  */
 function extractInlineMetadata({ options, output, config, }) {
     const metadata = {};
+    let contextDeriveExpr;
     if (options && options.type === 'ObjectExpression') {
         options.properties.forEach((prop) => {
             if (prop.type === 'ObjectProperty' && prop.key.type === 'Identifier') {
@@ -67,7 +69,13 @@ function extractInlineMetadata({ options, output, config, }) {
                     t.isExpression(prop.value)) {
                     const result = isStaticExpression(prop.value);
                     if (!result.isStatic) {
-                        output.errors.push(warnNonStaticExpressionSync(config.file, attribute, generate(prop.value).code, `${prop.loc?.start?.line}:${prop.loc?.start?.column}`));
+                        const mappedKey = mapAttributeName(attribute);
+                        if (mappedKey === 'context' && containsDeriveCall(prop.value)) {
+                            contextDeriveExpr = prop.value;
+                        }
+                        else {
+                            output.errors.push(warnNonStaticExpressionSync(config.file, attribute, generate(prop.value).code, `${prop.loc?.start?.line}:${prop.loc?.start?.column}`));
+                        }
                     }
                     if (result.isStatic &&
                         result.value != null &&
@@ -107,5 +115,8 @@ function extractInlineMetadata({ options, output, config, }) {
             }
         });
     }
-    return metadata;
+    return {
+        ...metadata,
+        ...(contextDeriveExpr && { contextDeriveExpr }),
+    };
 }

package/dist/react/jsx/utils/stringParsing/processTranslationCall/handleDeriveTranslationCall.d.ts

@@ -12,11 +12,12 @@ import { InlineMetadata } from './extractStringEntryMetadata.js';
  * @param output - The output to use
  * @param index - Current index in array of strings being extracted
  */
-export declare function handleDeriveTranslationCall({ arg, metadata, tPath, config, output, index, }: {
+export declare function handleDeriveTranslationCall({ arg, metadata, tPath, config, output, index, contextVariants, }: {
     arg: t.Expression;
     metadata: InlineMetadata;
     tPath: NodePath;
     config: ParsingConfig;
     output: ParsingOutput;
     index?: number;
+    contextVariants?: string[];
 }): void;

package/dist/react/jsx/utils/stringParsing/processTranslationCall/handleDeriveTranslationCall.js

@@ -8,7 +8,7 @@ import { deriveExpression } from '../derivation/index.js';
  * @param output - The output to use
  * @param index - Current index in array of strings being extracted
  */
-export function handleDeriveTranslationCall({ arg, metadata, tPath, config, output, index, }) {
+export function handleDeriveTranslationCall({ arg, metadata, tPath, config, output, index, contextVariants, }) {
     deriveExpression({
         tPath,
         expr: arg,
@@ -16,5 +16,6 @@ export function handleDeriveTranslationCall({ arg, metadata, tPath, config, outp
         config,
         output,
         index,
+        contextVariants,
     });
 }

package/dist/react/jsx/utils/stringParsing/processTranslationCall/handleLiteralTranslationCall.d.ts

@@ -9,11 +9,13 @@ import { InlineMetadata } from './extractStringEntryMetadata.js';
  * @param config - The configuration to use
  * @param output - The output to use
  * @param index - The index of the argument
+ * @param contextVariants - Optional derive context variants for cross-product
  */
-export declare function handleLiteralTranslationCall({ arg, metadata, config, output, index, }: {
+export declare function handleLiteralTranslationCall({ arg, metadata, config, output, index, contextVariants, }: {
     arg: t.StringLiteral | t.TemplateLiteral;
     metadata: InlineMetadata;
     config: ParsingConfig;
     output: ParsingOutput;
     index?: number;
+    contextVariants?: string[];
 }): void;

package/dist/react/jsx/utils/stringParsing/processTranslationCall/handleLiteralTranslationCall.js

@@ -1,5 +1,6 @@
 import { isValidIcu } from '../../../evaluateJsx.js';
 import { warnInvalidIcuSync } from '../../../../../console/index.js';
+import { randomUUID } from 'node:crypto';
 /**
  * For the processTranslationCall function, this function handles the case where a string literal or template literal is used.
  * @param arg - The argument to parse
@@ -7,8 +8,9 @@ import { warnInvalidIcuSync } from '../../../../../console/index.js';
  * @param config - The configuration to use
  * @param output - The output to use
  * @param index - The index of the argument
+ * @param contextVariants - Optional derive context variants for cross-product
  */
-export function handleLiteralTranslationCall({ arg, metadata, config, output, index, }) {
+export function handleLiteralTranslationCall({ arg, metadata, config, output, index, contextVariants, }) {
     // ignore dynamic content flag is triggered, check strings are valid ICU
     const source = arg.type === 'StringLiteral' ? arg.value : arg.quasis[0].value.raw;
     // Validate is ICU — skip for non-ICU formats
@@ -20,13 +22,31 @@ export function handleLiteralTranslationCall({ arg, metadata, config, output, in
             return;
         }
     }
-    output.updates.push({
-        dataFormat: (metadata.format || 'ICU'),
-        source,
-        metadata: {
-            ...metadata,
-            // Add the index if an id and index is provided (for handling when registering an array of strings)
-            ...(metadata.id && index != null && { id: `${metadata.id}.${index}` }),
-        },
-    });
+    if (contextVariants) {
+        const staticId = `derive-temp-id-${randomUUID()}`;
+        for (const context of contextVariants) {
+            output.updates.push({
+                dataFormat: (metadata.format || 'ICU'),
+                source,
+                metadata: {
+                    ...metadata,
+                    context,
+                    ...(metadata.id &&
+                        index != null && { id: `${metadata.id}.${index}` }),
+                    staticId,
+                },
+            });
+        }
+    }
+    else {
+        output.updates.push({
+            dataFormat: (metadata.format || 'ICU'),
+            source,
+            metadata: {
+                ...metadata,
+                // Add the index if an id and index is provided (for handling when registering an array of strings)
+                ...(metadata.id && index != null && { id: `${metadata.id}.${index}` }),
+            },
+        });
+    }
 }

package/dist/react/jsx/utils/stringParsing/processTranslationCall/index.js

@@ -1,6 +1,8 @@
 import { routeTranslationCall } from './routeTranslationCall.js';
 import { extractStringEntryMetadata } from './extractStringEntryMetadata.js';
 import { SURROUNDING_LINE_COUNT } from '../../../../../utils/constants.js';
+import { handleDerivation } from '../derivation/handleDerivation.js';
+import { nodeToStrings } from '../../parseString.js';
 /**
  * Processes a single translation function call (e.g., t('hello world', { id: 'greeting' })).
  * Extracts the translatable string content and metadata, then adds it to the updates array.
@@ -31,6 +33,22 @@ export function processTranslationCall(tPath, config, output) {
         nodeLoc: tPath.parent.loc,
         surroundingLineCount: SURROUNDING_LINE_COUNT,
     });
+    // Resolve derive context variants if present
+    let contextVariants;
+    if (metadata.contextDeriveExpr) {
+        const contextNode = handleDerivation({
+            expr: metadata.contextDeriveExpr,
+            tPath,
+            file: config.file,
+            parsingOptions: config.parsingOptions,
+            errors: output.errors,
+            warnings: output.warnings,
+        });
+        if (contextNode) {
+            contextVariants = nodeToStrings(contextNode);
+        }
+        delete metadata.contextDeriveExpr;
+    }
     // Route tx call to appropriate handler
     routeTranslationCall({
         tPath,
@@ -38,5 +56,6 @@ export function processTranslationCall(tPath, config, output) {
         output,
         arg,
         metadata,
+        contextVariants,
     });
 }

package/dist/react/jsx/utils/stringParsing/processTranslationCall/routeTranslationCall.d.ts

@@ -14,11 +14,12 @@ import { InlineMetadata } from './extractStringEntryMetadata.js';
  * @param index - The index of the argument
  * @returns void
  */
-export declare function routeTranslationCall({ tPath, config, output, arg, metadata, index, }: {
+export declare function routeTranslationCall({ tPath, config, output, arg, metadata, index, contextVariants, }: {
     tPath: NodePath;
     config: ParsingConfig;
     output: ParsingOutput;
     arg: t.CallExpression['arguments'][number];
     metadata: InlineMetadata;
     index?: number;
+    contextVariants?: string[];
 }): void;

package/dist/react/jsx/utils/stringParsing/processTranslationCall/routeTranslationCall.js

@@ -14,7 +14,7 @@ import * as t from '@babel/types';
  * @param index - The index of the argument
  * @returns void
  */
-export function routeTranslationCall({ tPath, config, output, arg, metadata, index, }) {
+export function routeTranslationCall({ tPath, config, output, arg, metadata, index, contextVariants, }) {
     if (t.isArrayExpression(arg) &&
         index == null &&
         !config.ignoreInlineListContent) {
@@ -30,6 +30,7 @@ export function routeTranslationCall({ tPath, config, output, arg, metadata, ind
                 arg: element,
                 index: i,
                 metadata,
+                contextVariants,
             });
         }
     }
@@ -44,6 +45,7 @@ export function routeTranslationCall({ tPath, config, output, arg, metadata, ind
             config,
             output,
             index,
+            contextVariants,
         });
     }
     else if (arg.type === 'StringLiteral' ||
@@ -55,6 +57,7 @@ export function routeTranslationCall({ tPath, config, output, arg, metadata, ind
             config,
             output,
             index,
+            contextVariants,
         });
     }
     else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gt",
-  "version": "2.14.5",
+  "version": "2.14.6",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [
@@ -110,9 +110,9 @@
     "unified": "^11.0.5",
     "unist-util-visit": "^5.0.0",
     "yaml": "^2.8.0",
-    "@generaltranslation/python-extractor": "0.2.6",
-    "gt-remark": "1.0.7",
-    "generaltranslation": "8.2.2"
+    "@generaltranslation/python-extractor": "0.2.7",
+    "generaltranslation": "8.2.2",
+    "gt-remark": "1.0.7"
   },
   "devDependencies": {
     "@babel/types": "^7.28.4",