gt 2.11.0 → 2.11.1

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # gtx-cli
 
+## 2.11.1
+
+### Patch Changes
+
+- [#1129](https://github.com/generaltranslation/gt/pull/1129) [`aabe764`](https://github.com/generaltranslation/gt/commit/aabe76422bfbba80ed3453667f82f01b1a195281) Thanks [@ErnestM1234](https://github.com/ErnestM1234)! - feat: derivation support for the t macro
+
+- Updated dependencies [[`aabe764`](https://github.com/generaltranslation/gt/commit/aabe76422bfbba80ed3453667f82f01b1a195281), [`84c1443`](https://github.com/generaltranslation/gt/commit/84c1443bda85ccbd8d8dbf56ede341de974db522)]:
+  - @generaltranslation/python-extractor@0.1.5
+  - generaltranslation@8.1.19
+
 ## 2.11.0
 
 ### Minor Changes

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const PACKAGE_VERSION = "2.11.0";
+export declare const PACKAGE_VERSION = "2.11.1";

package/dist/generated/version.js

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

package/dist/react/jsx/utils/constants.d.ts

@@ -20,6 +20,7 @@ export declare const DERIVE_COMPONENT = "Derive";
 export declare const BRANCH_COMPONENT = "Branch";
 export declare const GT_TRANSLATION_FUNCS: string[];
 export declare const STRING_REGISTRATION_FUNCS: readonly ["msg", "t"];
+export declare const GT_DERIVE_STRING_FUNCTIONS: string[];
 export declare const VARIABLE_COMPONENTS: string[];
 export declare const GT_ATTRIBUTES_WITH_SUGAR: readonly ["$id", "$context", "$maxChars"];
 export declare const GT_ATTRIBUTES: readonly ["id", "context", "maxChars", "$id", "$context", "$maxChars"];

package/dist/react/jsx/utils/constants.js

@@ -44,6 +44,11 @@ export const STRING_REGISTRATION_FUNCS = [
     MSG_REGISTRATION_FUNCTION,
     T_REGISTRATION_FUNCTION,
 ];
+// Derive functions that are imported from GT
+export const GT_DERIVE_STRING_FUNCTIONS = [
+    DECLARE_STATIC_FUNCTION,
+    DERIVE_FUNCTION,
+];
 // Valid variable components
 export const VARIABLE_COMPONENTS = [
     'Var',

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

@@ -0,0 +1,30 @@
+import * as t from '@babel/types';
+import { NodePath } from '@babel/traverse';
+import { ParsingConfigOptions } from '../../../../../types/parsing.js';
+import { StringNode } from '../../types.js';
+export type StringTree = (string | StringTree)[];
+/**
+ * Extracts content if an expression is derivable (statically analyzable) or uses derive()
+ * Returns a Node representing the parsed expression
+ * @param expr - The expression to check
+ * @param tPath - NodePath for scope resolution
+ * @param file - Current file path
+ * @param parsingOptions - Parsing configuration
+ * @param errors - Errors to add to
+ * @param runtimeInterpolationState - When provided, non-derive dynamic expressions become {n} placeholders instead of errors. Pass { index: 0 } at the entry point for template macros.
+ * @returns Node | null - The parsed node, or null if invalid
+ *
+ * @note runtimeInterpolationState
+ *  - Only provide at entry for template macros, otherwise omit
+ *  - t`Hello {nonDerivableValue}` -> t`Hello {0}`
+ */
+export declare function handleDerivation({ expr, tPath, file, parsingOptions, errors, runtimeInterpolationState, }: {
+    expr: t.Expression;
+    tPath: NodePath;
+    file: string;
+    parsingOptions: ParsingConfigOptions;
+    errors: string[];
+    runtimeInterpolationState?: {
+        index: number;
+    };
+}): StringNode | null;

package/dist/react/jsx/utils/{parseDerive.js → stringParsing/derivation/handleDerivation.js}

@@ -1,13 +1,13 @@
 import * as t from '@babel/types';
-import { parseStringExpression, nodeToStrings } from './parseString.js';
-import { buildImportMap } from './buildImportMap.js';
-import { resolveImportPath } from './resolveImportPath.js';
+import { parseStringExpression, nodeToStrings } from '../../parseString.js';
+import { buildImportMap } from '../../buildImportMap.js';
+import { resolveImportPath } from '../../resolveImportPath.js';
 import { parse } from '@babel/parser';
 import fs from 'node:fs';
-import { warnFunctionNotFoundSync, warnDeriveFunctionNoResultsSync, warnDeriveFunctionNotWrappedSync, } from '../../../console/index.js';
-import { DECLARE_STATIC_FUNCTION, DERIVE_FUNCTION } from './constants.js';
+import { warnFunctionNotFoundSync, warnDeriveFunctionNoResultsSync, warnDeriveFunctionNotWrappedSync, } from '../../../../../console/index.js';
 import traverseModule from '@babel/traverse';
 import generateModule from '@babel/generator';
+import { isDeriveCall } from './isDeriveCall.js';
 // Handle CommonJS/ESM interop
 const traverse = traverseModule.default || traverseModule;
 const generate = generateModule.default || generateModule;
@@ -30,27 +30,49 @@ const processFunctionCache = new Map();
  * @param tPath - NodePath for scope resolution
  * @param file - Current file path
  * @param parsingOptions - Parsing configuration
+ * @param errors - Errors to add to
+ * @param runtimeInterpolationState - When provided, non-derive dynamic expressions become {n} placeholders instead of errors. Pass { index: 0 } at the entry point for template macros.
  * @returns Node | null - The parsed node, or null if invalid
+ *
+ * @note runtimeInterpolationState
+ *  - Only provide at entry for template macros, otherwise omit
+ *  - t`Hello {nonDerivableValue}` -> t`Hello {0}`
  */
-export function handleDeriveExpression(expr, tPath, file, parsingOptions, errors) {
+export function handleDerivation({ expr, tPath, file, parsingOptions, errors, runtimeInterpolationState, }) {
     if (!expr) {
         return null;
     }
     // Handle expressions
     if (t.isCallExpression(expr)) {
-        const variants = getDeriveVariants(expr, tPath, file, parsingOptions, errors);
-        if (variants) {
-            // We found derive() -> return as ChoiceNode
-            return {
-                type: 'choice',
-                nodes: variants.map((v) => ({ type: 'text', text: v })),
-            };
+        if (isDeriveCall({ expr, tPath })) {
+            const variants = getDeriveVariants({
+                call: expr,
+                tPath,
+                file,
+                parsingOptions,
+                errors,
+            });
+            if (variants) {
+                return {
+                    type: 'choice',
+                    nodes: variants.map((v) => ({ type: 'text', text: v })),
+                };
+            }
+            // derive() had no resolvable results
+            const code = expr.arguments.length > 0
+                ? generate(expr.arguments[0]).code
+                : 'no arguments';
+            errors.push(warnDeriveFunctionNoResultsSync(file, code, `${expr.loc?.start?.line}:${expr.loc?.start?.column}`));
+            return null;
+        }
+        // Non-derive call
+        if (runtimeInterpolationState) {
+            return { type: 'text', text: `{${runtimeInterpolationState.index++}}` };
         }
-        // Call has no results
-        const code = expr.arguments.length > 0
-            ? generate(expr.arguments[0]).code
-            : 'no arguments';
-        errors.push(warnDeriveFunctionNoResultsSync(file, code, `${expr.loc?.start?.line}:${expr.loc?.start?.column}`));
+        const calleeName = t.isIdentifier(expr.callee)
+            ? expr.callee.name
+            : generate(expr.callee).code;
+        errors.push(warnDeriveFunctionNotWrappedSync(file, calleeName, `${expr.callee.loc?.start?.line}:${expr.callee.loc?.start?.column}`));
         return null;
     }
     // Handle direct string literals
@@ -68,12 +90,33 @@ export function handleDeriveExpression(expr, tPath, file, parsingOptions, errors
             }
             const exprNode = expr.expressions[index];
             if (exprNode && t.isExpression(exprNode)) {
-                const result = handleDeriveExpression(exprNode, tPath, file, parsingOptions, errors);
-                if (result === null) {
-                    // Early bailout if we can't handle something inside interpolation
-                    return null;
+                if (isDeriveCall({ expr: exprNode, tPath })) {
+                    // Derive — resolve fully (no runtime interpolation forwarding)
+                    const result = handleDerivation({
+                        expr: exprNode,
+                        tPath,
+                        file,
+                        parsingOptions,
+                        errors,
+                    });
+                    if (result === null)
+                        return null;
+                    parts.push(result);
+                }
+                else {
+                    // Non-derive — recurse with runtime interpolation forwarded
+                    const result = handleDerivation({
+                        expr: exprNode,
+                        tPath,
+                        file,
+                        parsingOptions,
+                        errors,
+                        runtimeInterpolationState,
+                    });
+                    if (result === null)
+                        return null;
+                    parts.push(result);
                 }
-                parts.push(result);
             }
         }
         if (parts.length === 0) {
@@ -89,8 +132,22 @@ export function handleDeriveExpression(expr, tPath, file, parsingOptions, errors
         if (!t.isExpression(expr.left) || !t.isExpression(expr.right)) {
             return null;
         }
-        const leftResult = handleDeriveExpression(expr.left, tPath, file, parsingOptions, errors);
-        const rightResult = handleDeriveExpression(expr.right, tPath, file, parsingOptions, errors);
+        const leftResult = handleDerivation({
+            expr: expr.left,
+            tPath,
+            file,
+            parsingOptions,
+            errors,
+            runtimeInterpolationState,
+        });
+        const rightResult = handleDerivation({
+            expr: expr.right,
+            tPath,
+            file,
+            parsingOptions,
+            errors,
+            runtimeInterpolationState,
+        });
         if (leftResult === null || rightResult === null) {
             return null;
         }
@@ -98,7 +155,14 @@ export function handleDeriveExpression(expr, tPath, file, parsingOptions, errors
     }
     // Handle parenthesized expressions
     if (t.isParenthesizedExpression(expr)) {
-        return handleDeriveExpression(expr.expression, tPath, file, parsingOptions, errors);
+        return handleDerivation({
+            expr: expr.expression,
+            tPath,
+            file,
+            parsingOptions,
+            errors,
+            runtimeInterpolationState,
+        });
     }
     // Handle numeric literals by converting them to strings
     if (t.isNumericLiteral(expr)) {
@@ -135,6 +199,9 @@ export function handleDeriveExpression(expr, tPath, file, parsingOptions, errors
         return { type: 'text', text: 'null' };
     }
     // Not a derivable expression
+    if (runtimeInterpolationState) {
+        return { type: 'text', text: `{${runtimeInterpolationState.index++}}` };
+    }
     return null;
 }
 /**
@@ -147,37 +214,13 @@ export function handleDeriveExpression(expr, tPath, file, parsingOptions, errors
  *
  * Returns null if it can't be resolved.
  */
-function getDeriveVariants(call, tPath, file, parsingOptions, errors) {
+function getDeriveVariants({ call, tPath, file, parsingOptions, errors, }) {
     // --- Validate Callee --- //
-    // Must be derive(...) or an alias of it
-    if (!t.isIdentifier(call.callee)) {
-        const code = call.arguments.length > 0
-            ? generate(call.arguments[0]).code
-            : 'no arguments';
-        errors.push(warnDeriveFunctionNotWrappedSync(file, code, `${call.callee.loc?.start?.line}:${call.callee.loc?.start?.column}`));
-        return null;
-    }
-    // Check if this is derive by name or by checking the import
-    const calleeName = call.callee.name;
-    const calleeBinding = tPath.scope.getBinding(calleeName);
-    // If it's not literally named 'derive', check if it's imported from GT
-    if (!calleeBinding) {
-        return null;
-    }
-    // Check if it's imported from a GT package
-    if (calleeBinding.path.isImportSpecifier()) {
-        const imported = calleeBinding.path.node.imported;
-        const originalName = t.isIdentifier(imported)
-            ? imported.name
-            : imported.value;
-        // Only proceed if the original name is 'derive' (or the deprecated 'declareStatic')
-        if (originalName !== DECLARE_STATIC_FUNCTION &&
-            originalName !== DERIVE_FUNCTION) {
-            return null;
-        }
-    }
-    else {
-        // Not an import specifier, so it's not derive
+    // Must be a derive(...) call or an alias of it
+    if (!isDeriveCall({ expr: call, tPath })) {
+        const calleeName = t.isIdentifier(call.callee)
+            ? call.callee.name
+            : generate(call.callee).code;
         errors.push(warnDeriveFunctionNotWrappedSync(file, calleeName, `${call.callee.loc?.start?.line}:${call.callee.loc?.start?.column}`));
         return null;
     }
@@ -507,13 +550,3 @@ function resolveFunctionInFile(filePath, functionName, parsingOptions, errors) {
     processFunctionCache.set(cacheKey, result);
     return result;
 }
-/**
- * Handle cond ? "a" : "b"
- * Collects string literals from both branches of a conditional expression
- */
-function collectConditionalStringVariants(cond, out) {
-    if (t.isStringLiteral(cond.consequent))
-        out.add(cond.consequent.value);
-    if (t.isStringLiteral(cond.alternate))
-        out.add(cond.alternate.value);
-}

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

@@ -0,0 +1,25 @@
+import { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+import { InlineMetadata } from '../processTranslationCall/extractStringEntryMetadata.js';
+import { ParsingConfig } from '../types.js';
+import { ParsingOutput } from '../types.js';
+/**
+ * Registers an expression with support for derive
+ * Entry point for string derivation
+ *
+ * @param tPath - The path to the tag identifier
+ * @param expr - The expression to parse
+ * @param metadata - Extracted metadata (empty for tagged templates)
+ * @param config - Parsing configuration
+ * @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, }: {
+    tPath: NodePath;
+    expr: t.Expression;
+    metadata: InlineMetadata;
+    config: ParsingConfig;
+    output: ParsingOutput;
+    index?: number;
+    enableRuntimeInterpolation?: boolean;
+}): void;

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

@@ -0,0 +1,63 @@
+import { handleDerivation } from './handleDerivation.js';
+import { warnNonStringSync } from '../../../../../console/index.js';
+import { nodeToStrings } from '../../parseString.js';
+import generateModule from '@babel/generator';
+import { indexVars } from 'generaltranslation/internal';
+import { randomUUID } from 'node:crypto';
+import { isValidIcu } from '../../../evaluateJsx.js';
+import { warnInvalidIcuSync } from '../../../../../console/index.js';
+// Handle CommonJS/ESM interop
+const generate = generateModule.default || generateModule;
+/**
+ * Registers an expression with support for derive
+ * Entry point for string derivation
+ *
+ * @param tPath - The path to the tag identifier
+ * @param expr - The expression to parse
+ * @param metadata - Extracted metadata (empty for tagged templates)
+ * @param config - Parsing configuration
+ * @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, }) {
+    // parse derivable expression
+    const stringNode = handleDerivation({
+        expr,
+        tPath,
+        file: config.file,
+        parsingOptions: config.parsingOptions,
+        errors: output.errors,
+        runtimeInterpolationState: enableRuntimeInterpolation
+            ? { index: 0 }
+            : undefined,
+    });
+    // Nothing returned, push error
+    if (!stringNode) {
+        output.errors.push(warnNonStringSync(config.file, generate(expr).code, `${expr.loc?.start?.line}:${expr.loc?.start?.column}`));
+        return;
+    }
+    // validate ICU
+    const strings = nodeToStrings(stringNode).map(indexVars);
+    if (!config.ignoreInvalidIcu) {
+        for (const string of strings) {
+            const { isValid, error } = isValidIcu(string);
+            if (!isValid) {
+                output.warnings.add(warnInvalidIcuSync(config.file, string, error ?? 'Unknown error', `${expr.loc?.start?.line}:${expr.loc?.start?.column}`));
+                return;
+            }
+        }
+    }
+    const temporaryDeriveId = `derive-temp-id-${randomUUID()}`;
+    for (const string of strings) {
+        output.updates.push({
+            dataFormat: '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,
+            },
+        });
+    }
+}

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

@@ -0,0 +1,11 @@
+import * as t from '@babel/types';
+import { NodePath } from '@babel/traverse';
+/**
+ * Given an expression, determine if it is a derive call
+ * @param expr - The expression to check
+ * @returns True if the expression is a derive call, false otherwise
+ */
+export declare function isDeriveCall({ expr, tPath, }: {
+    expr: t.Expression;
+    tPath: NodePath;
+}): boolean;

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

@@ -0,0 +1,38 @@
+import * as t from '@babel/types';
+import { GT_DERIVE_STRING_FUNCTIONS } from '../../constants.js';
+import { GT_LIBRARIES } from '../../../../../types/libraries.js';
+/**
+ * Given an expression, determine if it is a derive call
+ * @param expr - The expression to check
+ * @returns True if the expression is a derive call, false otherwise
+ */
+export function isDeriveCall({ expr, tPath, }) {
+    // Check if the expression is a call expression
+    if (!t.isCallExpression(expr))
+        return false;
+    const callee = expr.callee;
+    if (!t.isIdentifier(callee))
+        return false;
+    // Fail if no binding
+    const calleeName = callee.name;
+    const binding = tPath.scope.getBinding(calleeName);
+    if (!binding)
+        return false;
+    // Check if the callee is imported from GT
+    if (!binding.path.isImportSpecifier())
+        return false;
+    const source = binding.path.parentPath?.isImportDeclaration()
+        ? binding.path.parentPath?.node.source.value
+        : undefined;
+    if (!GT_LIBRARIES.includes(source))
+        return false;
+    // Fail if the original name is not 'derive' (or the deprecated 'declareStatic')
+    const imported = binding.path.node.imported;
+    const originalName = t.isIdentifier(imported)
+        ? imported.name
+        : imported.value;
+    if (!GT_DERIVE_STRING_FUNCTIONS.includes(originalName)) {
+        return false;
+    }
+    return true;
+}

package/dist/react/jsx/utils/stringParsing/processTaggedTemplateCall/handleTaggedTemplateTranslationCall.d.ts

@@ -1,6 +1,7 @@
 import * as t from '@babel/types';
 import { ParsingConfig, ParsingOutput } from '../types.js';
 import { InlineMetadata } from '../processTranslationCall/extractStringEntryMetadata.js';
+import { NodePath } from '@babel/traverse';
 /**
  * Extracts a translatable message from a TaggedTemplateExpression.
  *
@@ -10,12 +11,14 @@ import { InlineMetadata } from '../processTranslationCall/extractStringEntryMeta
  * - Creates numeric placeholders ({0}, {1}, etc.) for each expression
  * - Joins all parts into the final source string
  *
+ * @param tPath - The path to the tag identifier
  * @param quasi - The TemplateLiteral from the TaggedTemplateExpression
  * @param metadata - Extracted metadata (empty for tagged templates)
  * @param config - Parsing configuration
  * @param output - Parsing output collectors
  */
-export declare function handleTaggedTemplateTranslationCall({ quasi, metadata, config, output, }: {
+export declare function handleTaggedTemplateTranslationCall({ tPath, quasi, metadata, config, output, }: {
+    tPath: NodePath;
     quasi: t.TemplateLiteral;
     metadata: InlineMetadata;
     config: ParsingConfig;

package/dist/react/jsx/utils/stringParsing/processTaggedTemplateCall/handleTaggedTemplateTranslationCall.js

@@ -1,5 +1,4 @@
-import { isValidIcu } from '../../../evaluateJsx.js';
-import { warnInvalidIcuSync } from '../../../../../console/index.js';
+import { deriveExpression } from '../derivation/index.js';
 /**
  * Extracts a translatable message from a TaggedTemplateExpression.
  *
@@ -9,34 +8,19 @@ import { warnInvalidIcuSync } from '../../../../../console/index.js';
  * - Creates numeric placeholders ({0}, {1}, etc.) for each expression
  * - Joins all parts into the final source string
  *
+ * @param tPath - The path to the tag identifier
  * @param quasi - The TemplateLiteral from the TaggedTemplateExpression
  * @param metadata - Extracted metadata (empty for tagged templates)
  * @param config - Parsing configuration
  * @param output - Parsing output collectors
  */
-export function handleTaggedTemplateTranslationCall({ quasi, metadata, config, output, }) {
-    const parts = [];
-    let varIndex = 0;
-    for (let i = 0; i < quasi.quasis.length; i++) {
-        parts.push(quasi.quasis[i].value.cooked ?? quasi.quasis[i].value.raw);
-        if (i < quasi.expressions.length) {
-            const key = varIndex.toString();
-            parts.push(`{${key}}`);
-            varIndex++;
-        }
-    }
-    const source = parts.join('');
-    // Validate ICU format
-    if (!config.ignoreInvalidIcu) {
-        const { isValid, error } = isValidIcu(source);
-        if (!isValid) {
-            output.warnings.add(warnInvalidIcuSync(config.file, source, error ?? 'Unknown error', `${quasi.loc?.start?.line}:${quasi.loc?.start?.column}`));
-            return;
-        }
-    }
-    output.updates.push({
-        dataFormat: 'ICU',
-        source,
+export function handleTaggedTemplateTranslationCall({ tPath, quasi, metadata, config, output, }) {
+    deriveExpression({
+        tPath,
+        expr: quasi,
         metadata,
+        config,
+        output,
+        enableRuntimeInterpolation: true,
     });
 }

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

@@ -16,6 +16,7 @@ export function processTaggedTemplateCall(tPath, config, output) {
         return;
     }
     handleTaggedTemplateTranslationCall({
+        tPath,
         quasi: tPath.parent.quasi,
         metadata: {},
         config,

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

@@ -1,12 +1,4 @@
-import { handleDeriveExpression } from '../../parseDerive.js';
-import { nodeToStrings } from '../../parseString.js';
-import { indexVars } from 'generaltranslation/internal';
-import { isValidIcu } from '../../../evaluateJsx.js';
-import { warnInvalidIcuSync, warnNonStringSync, } from '../../../../../console/index.js';
-import generateModule from '@babel/generator';
-import { randomUUID } from 'node:crypto';
-// Handle CommonJS/ESM interop
-const generate = generateModule.default || generateModule;
+import { deriveExpression } from '../derivation/index.js';
 /**
  * For the processTranslationCall function, this function handles the case where a string with derive is used.
  * @param arg - The argument to parse
@@ -17,35 +9,12 @@ const generate = generateModule.default || generateModule;
  * @param index - Current index in array of strings being extracted
  */
 export function handleDeriveTranslationCall({ arg, metadata, tPath, config, output, index, }) {
-    // parse derivable expression
-    const result = handleDeriveExpression(arg, tPath, config.file, config.parsingOptions, output.errors);
-    // Nothing returned, push error
-    if (!result) {
-        output.errors.push(warnNonStringSync(config.file, generate(arg).code, `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
-        return;
-    }
-    // validate ICU
-    const strings = nodeToStrings(result).map(indexVars);
-    if (!config.ignoreInvalidIcu) {
-        for (const string of strings) {
-            const { isValid, error } = isValidIcu(string);
-            if (!isValid) {
-                output.warnings.add(warnInvalidIcuSync(config.file, string, error ?? 'Unknown error', `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
-                return;
-            }
-        }
-    }
-    const temporaryDeriveId = `derive-temp-id-${randomUUID()}`;
-    for (const string of strings) {
-        output.updates.push({
-            dataFormat: '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,
-            },
-        });
-    }
+    deriveExpression({
+        tPath,
+        expr: arg,
+        metadata,
+        config,
+        output,
+        index,
+    });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gt",
-  "version": "2.11.0",
+  "version": "2.11.1",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [
@@ -110,8 +110,8 @@
     "unified": "^11.0.5",
     "unist-util-visit": "^5.0.0",
     "yaml": "^2.8.0",
-    "@generaltranslation/python-extractor": "0.1.4",
-    "generaltranslation": "8.1.18",
+    "@generaltranslation/python-extractor": "0.1.5",
+    "generaltranslation": "8.1.19",
     "gt-remark": "1.0.5"
   },
   "devDependencies": {

package/dist/react/jsx/utils/parseDerive.d.ts

@@ -1,15 +0,0 @@
-import * as t from '@babel/types';
-import { NodePath } from '@babel/traverse';
-import { ParsingConfigOptions } from '../../../types/parsing.js';
-import { StringNode } from './types.js';
-export type StringTree = (string | StringTree)[];
-/**
- * Extracts content if an expression is derivable (statically analyzable) or uses derive()
- * Returns a Node representing the parsed expression
- * @param expr - The expression to check
- * @param tPath - NodePath for scope resolution
- * @param file - Current file path
- * @param parsingOptions - Parsing configuration
- * @returns Node | null - The parsed node, or null if invalid
- */
-export declare function handleDeriveExpression(expr: t.Expression, tPath: NodePath, file: string, parsingOptions: ParsingConfigOptions, errors: string[]): StringNode | null;