gt 2.10.5 → 2.10.6

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # gtx-cli
 
+## 2.10.6
+
+### Patch Changes
+
+- [#1062](https://github.com/generaltranslation/gt/pull/1062) [`2274e23`](https://github.com/generaltranslation/gt/commit/2274e23d448c8a96d661d30e5c7fc737814c1fb0) Thanks [@ErnestM1234](https://github.com/ErnestM1234)! - refactor: rename static to derive, and deprecate static
+
+- Updated dependencies [[`2274e23`](https://github.com/generaltranslation/gt/commit/2274e23d448c8a96d661d30e5c7fc737814c1fb0)]:
+  - generaltranslation@8.1.17
+  - @generaltranslation/python-extractor@0.1.3
+
 ## 2.10.5
 
 ### Patch Changes

package/dist/console/index.d.ts

@@ -17,11 +17,11 @@ export declare const withLocation: (file: string, message: string, location?: st
 export declare const warnFunctionNotFoundSync: (file: string, functionName: string, location?: string) => string;
 export declare const warnInvalidDeclareVarNameSync: (file: string, value: 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 warnInvalidDeriveInitSync: (file: string, functionName: string, location?: string) => string;
 export declare const warnDataAttrOnBranch: (file: string, attrName: string, location?: string) => string;
 export declare const warnRecursiveFunctionCallSync: (file: string, functionName: string, location?: string) => string;
-export declare const warnDeclareStaticNotWrappedSync: (file: string, functionName: string, location?: string) => string;
-export declare const warnDeclareStaticNoResultsSync: (file: string, functionName: string, location?: string) => string;
+export declare const warnDeriveFunctionNotWrappedSync: (file: string, functionName: string, location?: string) => string;
+export declare const warnDeriveFunctionNoResultsSync: (file: string, functionName: string, location?: string) => string;
 export declare const noLocalesError = "No locales found! Provide a list of locales for translation, or specify them in your gt.config.json file.";
 export declare const noDefaultLocaleError = "No default locale found! Provide a default locale, or specify it in your gt.config.json file.";
 export declare const noFilesError = "Incorrect or missing files configuration! Make sure your files are configured correctly in your gt.config.json file.";

package/dist/console/index.js

@@ -2,15 +2,15 @@ import { BRANCH_COMPONENT } from '../react/jsx/utils/constants.js';
 import { colorizeFilepath, colorizeComponent, colorizeIdString, colorizeContent, colorizeLine, colorizeFunctionName, } from './colors.js';
 import { formatCodeClamp } from './formatting.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}`;
-const withDeclareStaticError = (message) => `declareStatic() rules violation: ${message}`;
+// Derive function related errors
+const withDeriveComponentError = (message) => `<Derive> rules violation: ${message}`;
+const withDeriveFunctionError = (message) => `derive() rules violation: ${message}`;
 // Synchronous wrappers for backward compatibility
 export const warnApiKeyInConfigSync = (optionsFilepath) => `${colorizeFilepath(optionsFilepath)}: Your API key is exposed! 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);
+export const warnInvalidReturnSync = (file, functionName, expression, location) => withLocation(file, withDeriveComponentError(`Function ${colorizeFunctionName(functionName)} does not return a derivable (statically analyzable) expression. ${colorizeFunctionName(functionName)} must return either (1) a derivable string literal, (2) another derivable function invocation, (3) derivable 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 warnMissingReturnSync = (file, functionName, location) => withLocation(file, `Function ${colorizeFunctionName(functionName)} is wrapped in ${colorizeComponent('<Derive>')} (formerly ${colorizeComponent('<Static>')}) tags but does not have an explicit return statement. Derivable functions must have an explicit return statement.`, 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 warnFailedToConstructJsxTreeSync = (file, code, location) => withLocation(file, `Failed to construct JsxTree! Call expression is not a valid createElement call: ${colorizeContent(code)}`, location);
 export const warnNestedTComponent = (file, location) => withLocation(file, `Found nested <T> component. <T> components cannot be directly nested.`, location);
@@ -24,15 +24,15 @@ export const warnSyncGetGT = (file, location) => withLocation(file, `Found getGT
 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 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 warnInvalidDeclareVarNameSync = (file, value, location) => withLocation(file, `Found invalid declareVar() $name tag. Must be a static expression. Received: ${colorizeContent(value)}.`, location);
+export const warnInvalidDeclareVarNameSync = (file, value, location) => withLocation(file, `Found invalid declareVar() $name tag. Must be a derivable (statically analyzable) expression. Received: ${colorizeContent(value)}.`, 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.
+export const warnInvalidDeriveInitSync = (file, functionName, location) => withLocation(file, withDeriveComponentError(`The definition for ${colorizeFunctionName(functionName)} could not be resolved. When using arrow syntax to define a derivable (statically analyzable) 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);
 export const warnDataAttrOnBranch = (file, attrName, location) => withLocation(file, `${colorizeComponent(`<${BRANCH_COMPONENT}>`)} component ignores attributes prefixed with ${colorizeIdString('"data-"')}. Found ${colorizeIdString(attrName)}. Remove it or use a different attribute name.`, location);
-export const warnRecursiveFunctionCallSync = (file, functionName, location) => withLocation(file, withStaticError(`Recursive function call detected: ${colorizeFunctionName(functionName)}. A static function cannot use recursive calls to construct its result.`), location);
-export const warnDeclareStaticNotWrappedSync = (file, functionName, location) => withLocation(file, withDeclareStaticError(`Could not resolve ${colorizeFunctionName(formatCodeClamp(functionName))}. This call is not wrapped in declareStatic(). Ensure the function is properly wrapped with declareStatic() and does not have circular import dependencies.`), location);
-export const warnDeclareStaticNoResultsSync = (file, functionName, location) => withLocation(file, withDeclareStaticError(`Could not resolve ${colorizeFunctionName(formatCodeClamp(functionName))}. DeclareStatic can only receive function invocations and cannot use undefined values or looped calls to construct its result.`), location);
+export const warnRecursiveFunctionCallSync = (file, functionName, location) => withLocation(file, withDeriveComponentError(`Recursive function call detected: ${colorizeFunctionName(functionName)}. A derivable (statically analyzable) function cannot use recursive calls to construct its result.`), location);
+export const warnDeriveFunctionNotWrappedSync = (file, functionName, location) => withLocation(file, withDeriveFunctionError(`Could not resolve ${colorizeFunctionName(formatCodeClamp(functionName))}. This call is not wrapped in derive() (formerly declareStatic()). Ensure the function is properly wrapped with derive() and does not have circular import dependencies.`), location);
+export const warnDeriveFunctionNoResultsSync = (file, functionName, location) => withLocation(file, withDeriveFunctionError(`Could not resolve ${colorizeFunctionName(formatCodeClamp(functionName))}. derive() (formerly declareStatic()) can only receive function invocations and cannot use undefined values or looped calls to construct its result.`), location);
 // Re-export error messages
 export const noLocalesError = `No locales found! Provide a list of locales for translation, or specify them in your gt.config.json file.`;
 export const noDefaultLocaleError = `No default locale found! Provide a default locale, or specify it in your gt.config.json file.`;

package/dist/console/logging.d.ts

@@ -43,7 +43,6 @@ export declare function warnApiKeyInConfig(optionsFilepath: string): void;
 export declare function warnVariableProp(file: string, attrName: string, value: string): void;
 export declare function warnNoId(file: string): void;
 export declare function warnHasUnwrappedExpression(file: string, id: string, unwrappedExpressions: string[]): void;
-export declare function warnNonStaticExpression(file: string, attrName: string, value: string): void;
 export declare function warnTemplateLiteral(file: string, value: string): void;
 export declare function warnTernary(file: string): void;
 /**

package/dist/console/logging.js

@@ -146,10 +146,6 @@ export function warnHasUnwrappedExpression(file, id, unwrappedExpressions) {
         chalk.blue('https://generaltranslation.com/docs') +
         chalk.white(') to translate this properly.'));
 }
-export function warnNonStaticExpression(file, attrName, value) {
-    logger.warn(`Found non-static expression in ${chalk.cyan(file)} for attribute ${attrName}: "${chalk.white(value)}". ` +
-        `Change "${attrName}" to ensure this content is translated.`);
-}
 export function warnTemplateLiteral(file, value) {
     logger.warn(`Found template literal with quasis (${value}) in ${chalk.cyan(file)}. ` +
         chalk.white('Change the template literal to a string to ensure this content is translated.'));

package/dist/extraction/index.d.ts

@@ -1,3 +1,3 @@
 export type { ExtractionResult, ExtractionMetadata } from './types.js';
 export { mapExtractionResultsToUpdates } from './mapToUpdates.js';
-export { calculateHashes, dedupeUpdates, linkStaticUpdates, } from './postProcess.js';
+export { calculateHashes, dedupeUpdates, linkDeriveUpdates, } from './postProcess.js';

package/dist/extraction/index.js

@@ -1,2 +1,2 @@
 export { mapExtractionResultsToUpdates } from './mapToUpdates.js';
-export { calculateHashes, dedupeUpdates, linkStaticUpdates, } from './postProcess.js';
+export { calculateHashes, dedupeUpdates, linkDeriveUpdates, } from './postProcess.js';

package/dist/extraction/postProcess.d.ts

@@ -8,7 +8,7 @@ export declare function calculateHashes(updates: Updates): Promise<void>;
  */
 export declare function dedupeUpdates(updates: Updates): void;
 /**
- * Mark static updates as related by attaching a shared id to static content.
- * Id is calculated as the hash of the static children's combined hashes.
+ * Mark derive updates as related by attaching a shared id to derive content.
+ * Id is calculated as the hash of the derive children's combined hashes.
  */
-export declare function linkStaticUpdates(updates: Updates): void;
+export declare function linkDeriveUpdates(updates: Updates): void;

package/dist/extraction/postProcess.js

@@ -66,11 +66,11 @@ export function dedupeUpdates(updates) {
     updates.splice(0, updates.length, ...mergedUpdates);
 }
 /**
- * Mark static updates as related by attaching a shared id to static content.
- * Id is calculated as the hash of the static children's combined hashes.
+ * Mark derive updates as related by attaching a shared id to derive content.
+ * Id is calculated as the hash of the derive children's combined hashes.
  */
-export function linkStaticUpdates(updates) {
-    const temporaryStaticIdToUpdates = updates.reduce((acc, update) => {
+export function linkDeriveUpdates(updates) {
+    const temporaryDeriveIdToUpdates = updates.reduce((acc, update) => {
         if (update.metadata.staticId) {
             if (!acc[update.metadata.staticId]) {
                 acc[update.metadata.staticId] = [];
@@ -79,14 +79,14 @@ export function linkStaticUpdates(updates) {
         }
         return acc;
     }, {});
-    Object.values(temporaryStaticIdToUpdates).forEach((staticUpdates) => {
-        const hashes = staticUpdates
+    Object.values(temporaryDeriveIdToUpdates).forEach((deriveUpdates) => {
+        const hashes = deriveUpdates
             .map((update) => update.metadata.hash)
             .sort()
             .join('-');
-        const sharedStaticId = hashString(hashes);
-        staticUpdates.forEach((update) => {
-            update.metadata.staticId = sharedStaticId;
+        const sharedDeriveId = hashString(hashes);
+        deriveUpdates.forEach((update) => {
+            update.metadata.staticId = sharedDeriveId;
         });
     });
 }

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const PACKAGE_VERSION = "2.10.5";
+export declare const PACKAGE_VERSION = "2.10.6";

package/dist/generated/version.js

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

package/dist/python/parse/createPythonInlineUpdates.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import { extractFromPythonSource } from '@generaltranslation/python-extractor';
 import { mapExtractionResultsToUpdates } from '../../extraction/mapToUpdates.js';
-import { calculateHashes, dedupeUpdates, linkStaticUpdates, } from '../../extraction/postProcess.js';
+import { calculateHashes, dedupeUpdates, linkDeriveUpdates, } from '../../extraction/postProcess.js';
 import { matchFiles } from '../../fs/matchFiles.js';
 import { DEFAULT_PYTHON_SRC_PATTERNS, DEFAULT_PYTHON_SRC_EXCLUDES, } from '../../config/generateSettings.js';
 export async function createPythonInlineUpdates(filePatterns) {
@@ -29,6 +29,6 @@ export async function createPythonInlineUpdates(filePatterns) {
     // Post processing steps
     await calculateHashes(updates);
     dedupeUpdates(updates);
-    linkStaticUpdates(updates);
+    linkDeriveUpdates(updates);
     return { updates, errors, warnings };
 }

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

@@ -17,7 +17,17 @@ export declare function isStaticExpression(expr: t.Expression | t.JSXEmptyExpres
     isStatic: boolean;
     value?: string | boolean | null;
 };
+/**
+ * Checks if an expression is a static value (a string, number, or template literal).
+ * @param expr - The expression to check
+ * @returns Whether the expression is a static value
+ */
 export declare function isStaticValue(expr: t.Expression | t.JSXEmptyExpression): boolean;
+/**
+ * Checks if a string is a valid ICU message format.
+ * @param string - The string to check
+ * @returns Whether the string is a valid ICU message format
+ */
 export declare function isValidIcu(string: string): {
     isValid: boolean;
     error?: string;

package/dist/react/jsx/evaluateJsx.js

@@ -28,9 +28,9 @@ export function isMeaningful(node) {
     return false;
 }
 /**
- * Checks if an expression is static (does not contain any variables which could change at runtime).
+ * Checks if an expression is a static expression (does not contain any variables which could change at runtime).
  * @param expr - The expression to check
- * @param ignoreStaticFunction - Whether to ignore static functions
+ * @param jsxStatic - Whether to return JSX-compatible values (boolean, null) in addition to strings
  * @returns An object containing the result of the static check
  */
 export function isStaticExpression(expr, jsxStatic = false) {
@@ -49,9 +49,9 @@ export function isStaticExpression(expr, jsxStatic = false) {
             value: jsxStatic ? expr.quasis[0].value.cooked : expr.quasis[0].value.raw,
         };
     }
-    // Binary expressions are not static
+    // Binary expressions are not derivable
     if (t.isBinaryExpression(expr)) {
-        // Not a static expression
+        // Not a derivable expression
         return { isStatic: false };
     }
     // Handle parenthesized expressions
@@ -94,9 +94,14 @@ export function isStaticExpression(expr, jsxStatic = false) {
     if (t.isNullLiteral(expr)) {
         return { isStatic: true, value: jsxStatic ? null : 'null' };
     }
-    // Not a static expression
+    // Not a derivable expression
     return { isStatic: false };
 }
+/**
+ * Checks if an expression is a static value (a string, number, or template literal).
+ * @param expr - The expression to check
+ * @returns Whether the expression is a static value
+ */
 export function isStaticValue(expr) {
     if (t.isStringLiteral(expr)) {
         return true;
@@ -109,6 +114,11 @@ export function isStaticValue(expr) {
     }
     return false;
 }
+/**
+ * Checks if a string is a valid ICU message format.
+ * @param string - The string to check
+ * @returns Whether the string is a valid ICU message format
+ */
 export function isValidIcu(string) {
     try {
         parse(string);

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

@@ -1,5 +1,9 @@
 export declare const DECLARE_VAR_FUNCTION = "declareVar";
+/**
+ * COMPAT: Legacy support for declareStatic function.
+ */
 export declare const DECLARE_STATIC_FUNCTION = "declareStatic";
+export declare const DERIVE_FUNCTION = "derive";
 export declare const MSG_REGISTRATION_FUNCTION = "msg";
 export declare const T_REGISTRATION_FUNCTION = "t";
 export declare const INLINE_TRANSLATION_HOOK = "useGT";
@@ -7,7 +11,11 @@ export declare const INLINE_TRANSLATION_HOOK_ASYNC = "getGT";
 export declare const INLINE_MESSAGE_HOOK = "useMessages";
 export declare const INLINE_MESSAGE_HOOK_ASYNC = "getMessages";
 export declare const TRANSLATION_COMPONENT = "T";
+/**
+ * COMPAT: Legacy support for Static component.
+ */
 export declare const STATIC_COMPONENT = "Static";
+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"];

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

@@ -1,5 +1,9 @@
 export const DECLARE_VAR_FUNCTION = 'declareVar';
+/**
+ * COMPAT: Legacy support for declareStatic function.
+ */
 export const DECLARE_STATIC_FUNCTION = 'declareStatic';
+export const DERIVE_FUNCTION = 'derive';
 export const MSG_REGISTRATION_FUNCTION = 'msg';
 export const T_REGISTRATION_FUNCTION = 't';
 export const INLINE_TRANSLATION_HOOK = 'useGT';
@@ -7,7 +11,11 @@ export const INLINE_TRANSLATION_HOOK_ASYNC = 'getGT';
 export const INLINE_MESSAGE_HOOK = 'useMessages';
 export const INLINE_MESSAGE_HOOK_ASYNC = 'getMessages';
 export const TRANSLATION_COMPONENT = 'T';
+/**
+ * COMPAT: Legacy support for Static component.
+ */
 export const STATIC_COMPONENT = 'Static';
+export const DERIVE_COMPONENT = 'Derive';
 export const BRANCH_COMPONENT = 'Branch';
 // GT translation functions
 export const GT_TRANSLATION_FUNCS = [
@@ -19,8 +27,10 @@ export const GT_TRANSLATION_FUNCS = [
     T_REGISTRATION_FUNCTION,
     DECLARE_VAR_FUNCTION,
     DECLARE_STATIC_FUNCTION,
+    DERIVE_FUNCTION,
     TRANSLATION_COMPONENT,
     STATIC_COMPONENT,
+    DERIVE_COMPONENT,
     'Var',
     'DateTime',
     'Currency',
@@ -40,6 +50,7 @@ export const VARIABLE_COMPONENTS = [
     'Currency',
     'Num',
     STATIC_COMPONENT,
+    DERIVE_COMPONENT,
 ];
 export const GT_ATTRIBUTES_WITH_SUGAR = [
     '$id',

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

@@ -67,7 +67,7 @@ export function trimJsxStringChild(child) {
  * @param currentTree - The current tree to handle
  * @returns The processed tree with whitespace handled
  *
- * For unresolved functions, we just make it so that Static has no children
+ * For unresolved functions, we just make it so that Derive has no children
  *
  * The typing was so much worse before this. Don't come for me. All I did was enforce the typing.
  */

package/dist/react/jsx/utils/jsxParsing/multiplication/multiplyJsxTree.d.ts

@@ -1,5 +1,5 @@
 import { MultipliedTreeNode, WhitespaceJsxTreeResult } from '../types.js';
 /**
- * Given a JSX tree, multiply the static function nodes
+ * Given a JSX tree, multiply the derived function nodes
  */
 export declare function multiplyJsxTree(tree: WhitespaceJsxTreeResult | WhitespaceJsxTreeResult[]): MultipliedTreeNode[];

package/dist/react/jsx/utils/jsxParsing/multiplication/multiplyJsxTree.js

@@ -1,6 +1,6 @@
 import { findMultiplicationNode } from './findMultiplicationNode.js';
 /**
- * Given a JSX tree, multiply the static function nodes
+ * Given a JSX tree, multiply the derived function nodes
  */
 export function multiplyJsxTree(tree) {
     if (!Array.isArray(tree)) {

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

@@ -6,10 +6,10 @@ import * as t from '@babel/types';
 import fs from 'node:fs';
 import { parse } from '@babel/parser';
 import addGTIdentifierToSyntaxTree from './addGTIdentifierToSyntaxTree.js';
-import { warnHasUnwrappedExpressionSync, warnNestedTComponent, warnFunctionNotFoundSync, warnMissingReturnSync, warnDuplicateFunctionDefinitionSync, warnInvalidStaticInitSync, warnRecursiveFunctionCallSync, warnDataAttrOnBranch, } from '../../../../console/index.js';
+import { warnHasUnwrappedExpressionSync, warnNestedTComponent, warnFunctionNotFoundSync, warnMissingReturnSync, warnDuplicateFunctionDefinitionSync, warnInvalidDeriveInitSync, warnRecursiveFunctionCallSync, warnDataAttrOnBranch, } from '../../../../console/index.js';
 import { isAcceptedPluralForm } from 'generaltranslation/internal';
 import { isStaticExpression } from '../../evaluateJsx.js';
-import { DATA_ATTR_PREFIX, STATIC_COMPONENT, TRANSLATION_COMPONENT, VARIABLE_COMPONENTS, } from '../constants.js';
+import { DATA_ATTR_PREFIX, STATIC_COMPONENT, DERIVE_COMPONENT, TRANSLATION_COMPONENT, VARIABLE_COMPONENTS, } from '../constants.js';
 import { HTML_CONTENT_PROPS } from 'generaltranslation/types';
 import { resolveImportPath } from '../resolveImportPath.js';
 import traverseModule from '@babel/traverse';
@@ -64,7 +64,7 @@ export function parseTranslationComponent({ originalName, localName, path, updat
             state: {
                 visited: null,
                 callStack: [],
-                staticTracker: { isStatic: false },
+                derivableTracker: { isDerivable: false },
                 importedFunctionsMap,
             },
             output,
@@ -77,20 +77,20 @@ export function parseTranslationComponent({ originalName, localName, path, updat
  * @param helperPath - NodePath for AST traversal
  * @param scopeNode - Scope node for binding resolution
  * @param insideT - Whether the current node is inside a <T> component
- * @param inStatic - Whether we're inside a Static component
+ * @param inDerive - Whether we're inside a <Derive> component
  * @param config - Immutable configuration options
  * @param state - Mutable state tracking
  * @param output - Error/warning collectors
  * @returns The built JSX tree
  */
-function buildJSXTree({ node, helperPath, scopeNode, insideT, inStatic, config, state, output, }) {
+function buildJSXTree({ node, helperPath, scopeNode, insideT, inDerive, config, state, output, }) {
     if (t.isJSXExpressionContainer(node)) {
         // Skip JSX comments
         if (t.isJSXEmptyExpression(node.expression)) {
             return null;
         }
-        if (inStatic) {
-            return processStaticExpression({
+        if (inDerive) {
+            return processDeriveExpression({
                 config,
                 state,
                 output,
@@ -103,7 +103,7 @@ function buildJSXTree({ node, helperPath, scopeNode, insideT, inStatic, config,
             return buildJSXTree({
                 node: expr,
                 insideT,
-                inStatic,
+                inDerive: inDerive,
                 scopeNode,
                 helperPath: helperPath.get('expression'),
                 config,
@@ -192,7 +192,7 @@ function buildJSXTree({ node, helperPath, scopeNode, insideT, inStatic, config,
                             attrValue = buildJSXTree({
                                 node: attr.value,
                                 insideT: true,
-                                inStatic,
+                                inDerive: inDerive,
                                 scopeNode,
                                 helperPath: helperValue,
                                 config,
@@ -215,11 +215,12 @@ function buildJSXTree({ node, helperPath, scopeNode, insideT, inStatic, config,
             }
         });
         if (elementIsVariable) {
-            if (componentType === STATIC_COMPONENT) {
+            if (componentType === STATIC_COMPONENT ||
+                componentType === DERIVE_COMPONENT) {
                 const helperElement = helperPath.get('children');
                 const results = {
                     nodeType: 'element',
-                    type: STATIC_COMPONENT,
+                    type: componentType,
                     props,
                 };
                 // Create children array if necessary
@@ -232,7 +233,7 @@ function buildJSXTree({ node, helperPath, scopeNode, insideT, inStatic, config,
                     const result = buildJSXTree({
                         node: helperChild.node,
                         insideT: true,
-                        inStatic: true,
+                        inDerive: true,
                         scopeNode,
                         helperPath: helperChild,
                         config,
@@ -258,7 +259,7 @@ function buildJSXTree({ node, helperPath, scopeNode, insideT, inStatic, config,
             .map((child, index) => buildJSXTree({
             node: child,
             insideT: true,
-            inStatic,
+            inDerive: inDerive,
             scopeNode,
             helperPath: helperPath.get('children')[index],
             config,
@@ -286,7 +287,7 @@ function buildJSXTree({ node, helperPath, scopeNode, insideT, inStatic, config,
             .map((child, index) => buildJSXTree({
             node: child,
             insideT: true,
-            inStatic,
+            inDerive: inDerive,
             scopeNode,
             helperPath: helperPath.get('children')[index],
             config,
@@ -313,7 +314,7 @@ function buildJSXTree({ node, helperPath, scopeNode, insideT, inStatic, config,
     }
     // If it's a template literal
     else if (t.isTemplateLiteral(node)) {
-        // We've already checked that it's static, and and added a warning if it's not, this check is just for fallback behavior
+        // We've already checked that it's derivable, and and added a warning if it's not, this check is just for fallback behavior
         if (!isStaticExpression(node, true).isStatic ||
             node.quasis[0].value.cooked === undefined) {
             return generate(node).code;
@@ -345,7 +346,7 @@ function buildJSXTree({ node, helperPath, scopeNode, insideT, inStatic, config,
         (t.isAwaitExpression(node) &&
             t.isCallExpression(node.argument) &&
             t.isIdentifier(node.argument.callee))) {
-        if (inStatic) {
+        if (inDerive) {
             const callExpression = (node.type === 'AwaitExpression' ? node.argument : node);
             const callee = callExpression.callee;
             const calleeBinding = scopeNode.scope.getBinding(callee.name);
@@ -353,7 +354,7 @@ function buildJSXTree({ node, helperPath, scopeNode, insideT, inStatic, config,
                 output.warnings.add(warnFunctionNotFoundSync(config.file, callee.name, `${callee.loc?.start?.line}:${callee.loc?.start?.column}`));
                 return null;
             }
-            return resolveStaticFunctionInvocationFromBinding({
+            return resolveDeriveFunctionInvocationFromBinding({
                 calleeBinding,
                 callee,
                 config,
@@ -370,7 +371,7 @@ function buildJSXTree({ node, helperPath, scopeNode, insideT, inStatic, config,
         return buildJSXTree({
             node: child,
             insideT,
-            inStatic,
+            inDerive: inDerive,
             scopeNode,
             helperPath: helperPath.get('expression'),
             config,
@@ -430,22 +431,22 @@ function parseJSXElement({ node, originalName, scopeNode, updates, config, state
         componentErrors,
         file: config.file,
     });
-    // Flag for if contains static content
-    const staticTracker = {
-        isStatic: false,
+    // Flag for if contains derivable content
+    const derivableTracker = {
+        isDerivable: false,
     };
     // Build the JSX tree for this component
     const treeResult = buildJSXTree({
         node,
         scopeNode,
         insideT: false,
-        inStatic: false,
+        inDerive: false,
         helperPath: scopeNode,
         config,
         state: {
             visited: null,
             callStack: [],
-            staticTracker,
+            derivableTracker: derivableTracker,
             importedFunctionsMap: state.importedFunctionsMap,
         },
         output: {
@@ -486,9 +487,8 @@ function parseJSXElement({ node, originalName, scopeNode, updates, config, state
         output.errors.push(warnHasUnwrappedExpressionSync(config.file, unwrappedExpressions, metadata.id, `${node.loc?.start?.line}:${node.loc?.start?.column}`));
         return;
     }
-    // Create a temporary unique flag for static content
-    const temporaryStaticId = `static-temp-id-${randomUUID()}`;
-    const isStatic = staticTracker.isStatic;
+    // Create a temporary unique flag for derivable content
+    const temporaryDeriveId = `derive-temp-id-${randomUUID()}`;
     // <T> is valid here
     for (const minifiedTree of minifiedTress) {
         // Clean the tree by removing null 'c' fields from JsxElements
@@ -499,12 +499,12 @@ function parseJSXElement({ node, originalName, scopeNode, updates, config, state
             metadata: {
                 // eslint-disable-next-line no-undef
                 ...structuredClone(metadata),
-                ...(isStatic && { staticId: temporaryStaticId }),
+                ...(derivableTracker.isDerivable && { staticId: temporaryDeriveId }),
             },
         });
     }
 }
-function resolveStaticFunctionInvocationFromBinding({ calleeBinding, callee, config, state, output, }) {
+function resolveDeriveFunctionInvocationFromBinding({ calleeBinding, callee, config, state, output, }) {
     function withRecusionGuard({ cb, filename, functionName, }) {
         const cacheKey = `${filename}::${functionName}`;
         if (state.callStack.includes(cacheKey)) {
@@ -760,7 +760,7 @@ function processFunctionDeclarationNodePath({ config, state, output, path, }) {
             if (!returnNodePath.isExpression()) {
                 return;
             }
-            result.branches.push(processStaticExpression({
+            result.branches.push(processDeriveExpression({
                 config,
                 state,
                 output,
@@ -788,13 +788,13 @@ function processVariableDeclarationNodePath({ config, state, output, functionNam
     // Enforce the Rhand is a function definition
     const arrowFunctionPath = path.get('init');
     if (!arrowFunctionPath.isArrowFunctionExpression()) {
-        output.errors.push(warnInvalidStaticInitSync(config.file, functionName, `${path.node.loc?.start?.line}:${path.node.loc?.start?.column}`));
+        output.errors.push(warnInvalidDeriveInitSync(config.file, functionName, `${path.node.loc?.start?.line}:${path.node.loc?.start?.column}`));
         return null;
     }
     const bodyNodePath = arrowFunctionPath.get('body');
     if (bodyNodePath.isExpression()) {
         // process expression return
-        result.branches.push(processStaticExpression({
+        result.branches.push(processDeriveExpression({
             config,
             state,
             output,
@@ -813,7 +813,7 @@ function processVariableDeclarationNodePath({ config, state, output, functionNam
                 if (!returnNodePath.isExpression()) {
                     return;
                 }
-                result.branches.push(processStaticExpression({
+                result.branches.push(processDeriveExpression({
                     config,
                     state,
                     output,
@@ -830,15 +830,15 @@ function processVariableDeclarationNodePath({ config, state, output, functionNam
     return result;
 }
 /**
- * Process a <Static> expression
+ * Process a <Derive> expression
  */
-function processStaticExpression({ config, state, output, expressionNodePath, scopeNode, }) {
-    // Mark the static tracker as true
-    state.staticTracker.isStatic = true;
+function processDeriveExpression({ config, state, output, expressionNodePath, scopeNode, }) {
+    // Mark the derivable tracker as true
+    state.derivableTracker.isDerivable = true;
     // Remove parentheses if they exist
     if (t.isParenthesizedExpression(expressionNodePath.node)) {
         // ex: return (value)
-        return processStaticExpression({
+        return processDeriveExpression({
             config,
             state,
             output,
@@ -856,7 +856,7 @@ function processStaticExpression({ config, state, output, expressionNodePath, sc
             return null;
         }
         // Function is found
-        return resolveStaticFunctionInvocationFromBinding({
+        return resolveDeriveFunctionInvocationFromBinding({
             calleeBinding,
             callee,
             config,
@@ -875,7 +875,7 @@ function processStaticExpression({ config, state, output, expressionNodePath, sc
             return null;
         }
         // Function is found
-        return resolveStaticFunctionInvocationFromBinding({
+        return resolveDeriveFunctionInvocationFromBinding({
             calleeBinding,
             callee,
             config,
@@ -891,7 +891,7 @@ function processStaticExpression({ config, state, output, expressionNodePath, sc
             helperPath: expressionNodePath,
             scopeNode,
             insideT: true,
-            inStatic: true,
+            inDerive: true,
             config,
             state,
             output,
@@ -904,7 +904,7 @@ function processStaticExpression({ config, state, output, expressionNodePath, sc
         const alternateNodePath = expressionNodePath.get('alternate');
         const result = {
             nodeType: 'multiplication',
-            branches: [consequentNodePath, alternateNodePath].map((expressionNodePath) => processStaticExpression({
+            branches: [consequentNodePath, alternateNodePath].map((expressionNodePath) => processDeriveExpression({
                 config,
                 state,
                 output,
@@ -920,7 +920,7 @@ function processStaticExpression({ config, state, output, expressionNodePath, sc
             helperPath: expressionNodePath,
             scopeNode,
             insideT: true,
-            inStatic: true,
+            inDerive: true,
             config,
             state,
             output,

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

@@ -24,13 +24,13 @@ export function parseTProps({ openingElement, metadata, componentErrors, file, }
             else if (t.isJSXExpressionContainer(attr.value)) {
                 const expr = attr.value.expression;
                 const code = generate(expr).code;
-                // Only check for static expressions on id and context and maxChars props
+                // Only check for derivable expressions on id and context and maxChars props
                 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}`));
                     }
-                    // Use the static value if available
+                    // Use the derived value if available
                     if (staticAnalysis.isStatic && staticAnalysis.value !== undefined) {
                         // Check for invalid maxChars values
                         if (attrName === '$maxChars' || attrName === 'maxChars') {
@@ -51,7 +51,7 @@ export function parseTProps({ openingElement, metadata, componentErrors, file, }
                         }
                     }
                     else {
-                        // Only store the code if we couldn't extract a static value
+                        // Only store the code if we couldn't extract a derivable value
                         metadata[attrName] = code;
                     }
                 }

package/dist/react/jsx/utils/{parseDeclareStatic.d.ts → parseDerive.d.ts}

@@ -4,7 +4,7 @@ import { ParsingConfigOptions } from '../../../types/parsing.js';
 import { StringNode } from './types.js';
 export type StringTree = (string | StringTree)[];
 /**
- * Checks if an expression is static or uses declareStatic
+ * 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
@@ -12,4 +12,4 @@ export type StringTree = (string | StringTree)[];
  * @param parsingOptions - Parsing configuration
  * @returns Node | null - The parsed node, or null if invalid
  */
-export declare function handleStaticExpression(expr: t.Expression, tPath: NodePath, file: string, parsingOptions: ParsingConfigOptions, errors: string[]): StringNode | null;
+export declare function handleDeriveExpression(expr: t.Expression, tPath: NodePath, file: string, parsingOptions: ParsingConfigOptions, errors: string[]): StringNode | null;

package/dist/react/jsx/utils/{parseDeclareStatic.js → parseDerive.js}

@@ -4,8 +4,8 @@ import { buildImportMap } from './buildImportMap.js';
 import { resolveImportPath } from './resolveImportPath.js';
 import { parse } from '@babel/parser';
 import fs from 'node:fs';
-import { warnFunctionNotFoundSync, warnDeclareStaticNoResultsSync, warnDeclareStaticNotWrappedSync, } from '../../../console/index.js';
-import { DECLARE_STATIC_FUNCTION } from './constants.js';
+import { warnFunctionNotFoundSync, warnDeriveFunctionNoResultsSync, warnDeriveFunctionNotWrappedSync, } from '../../../console/index.js';
+import { DECLARE_STATIC_FUNCTION, DERIVE_FUNCTION } from './constants.js';
 import traverseModule from '@babel/traverse';
 import generateModule from '@babel/generator';
 // Handle CommonJS/ESM interop
@@ -24,7 +24,7 @@ const resolveImportPathCache = new Map();
  */
 const processFunctionCache = new Map();
 /**
- * Checks if an expression is static or uses declareStatic
+ * 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
@@ -32,15 +32,15 @@ const processFunctionCache = new Map();
  * @param parsingOptions - Parsing configuration
  * @returns Node | null - The parsed node, or null if invalid
  */
-export function handleStaticExpression(expr, tPath, file, parsingOptions, errors) {
+export function handleDeriveExpression(expr, tPath, file, parsingOptions, errors) {
     if (!expr) {
         return null;
     }
     // Handle expressions
     if (t.isCallExpression(expr)) {
-        const variants = getDeclareStaticVariants(expr, tPath, file, parsingOptions, errors);
+        const variants = getDeriveVariants(expr, tPath, file, parsingOptions, errors);
         if (variants) {
-            // We found declareStatic -> return as ChoiceNode
+            // We found derive() -> return as ChoiceNode
             return {
                 type: 'choice',
                 nodes: variants.map((v) => ({ type: 'text', text: v })),
@@ -50,7 +50,7 @@ export function handleStaticExpression(expr, tPath, file, parsingOptions, errors
         const code = expr.arguments.length > 0
             ? generate(expr.arguments[0]).code
             : 'no arguments';
-        errors.push(warnDeclareStaticNoResultsSync(file, code, `${expr.loc?.start?.line}:${expr.loc?.start?.column}`));
+        errors.push(warnDeriveFunctionNoResultsSync(file, code, `${expr.loc?.start?.line}:${expr.loc?.start?.column}`));
         return null;
     }
     // Handle direct string literals
@@ -68,7 +68,7 @@ export function handleStaticExpression(expr, tPath, file, parsingOptions, errors
             }
             const exprNode = expr.expressions[index];
             if (exprNode && t.isExpression(exprNode)) {
-                const result = handleStaticExpression(exprNode, tPath, file, parsingOptions, errors);
+                const result = handleDeriveExpression(exprNode, tPath, file, parsingOptions, errors);
                 if (result === null) {
                     // Early bailout if we can't handle something inside interpolation
                     return null;
@@ -89,8 +89,8 @@ export function handleStaticExpression(expr, tPath, file, parsingOptions, errors
         if (!t.isExpression(expr.left) || !t.isExpression(expr.right)) {
             return null;
         }
-        const leftResult = handleStaticExpression(expr.left, tPath, file, parsingOptions, errors);
-        const rightResult = handleStaticExpression(expr.right, tPath, file, parsingOptions, errors);
+        const leftResult = handleDeriveExpression(expr.left, tPath, file, parsingOptions, errors);
+        const rightResult = handleDeriveExpression(expr.right, tPath, file, parsingOptions, errors);
         if (leftResult === null || rightResult === null) {
             return null;
         }
@@ -98,7 +98,7 @@ export function handleStaticExpression(expr, tPath, file, parsingOptions, errors
     }
     // Handle parenthesized expressions
     if (t.isParenthesizedExpression(expr)) {
-        return handleStaticExpression(expr.expression, tPath, file, parsingOptions, errors);
+        return handleDeriveExpression(expr.expression, tPath, file, parsingOptions, errors);
     }
     // Handle numeric literals by converting them to strings
     if (t.isNumericLiteral(expr)) {
@@ -134,33 +134,33 @@ export function handleStaticExpression(expr, tPath, file, parsingOptions, errors
     if (t.isNullLiteral(expr)) {
         return { type: 'text', text: 'null' };
     }
-    // Not a static expression
+    // Not a derivable expression
     return null;
 }
 /**
- * Given a CallExpression, if it is declareStatic(<call>) or declareStatic(await <call>),
+ * Given a CallExpression, if it is derive(<call>) or derive(await <call>),
  * return all possible string outcomes of that argument call as an array of strings.
  *
  * Examples:
- *   declareStatic(time()) -> ["day", "night"]
- *   declareStatic(await time()) -> ["day", "night"]
+ *   derive(time()) -> ["day", "night"]
+ *   derive(await time()) -> ["day", "night"]
  *
  * Returns null if it can't be resolved.
  */
-function getDeclareStaticVariants(call, tPath, file, parsingOptions, errors) {
+function getDeriveVariants(call, tPath, file, parsingOptions, errors) {
     // --- Validate Callee --- //
-    // Must be declareStatic(...) or an alias of it
+    // 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(warnDeclareStaticNotWrappedSync(file, code, `${call.callee.loc?.start?.line}:${call.callee.loc?.start?.column}`));
+        errors.push(warnDeriveFunctionNotWrappedSync(file, code, `${call.callee.loc?.start?.line}:${call.callee.loc?.start?.column}`));
         return null;
     }
-    // Check if this is declareStatic by name or by checking the import
+    // 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 'declareStatic', check if it's imported from GT
+    // If it's not literally named 'derive', check if it's imported from GT
     if (!calleeBinding) {
         return null;
     }
@@ -170,14 +170,15 @@ function getDeclareStaticVariants(call, tPath, file, parsingOptions, errors) {
         const originalName = t.isIdentifier(imported)
             ? imported.name
             : imported.value;
-        // Only proceed if the original name is 'declareStatic'
-        if (originalName !== DECLARE_STATIC_FUNCTION) {
+        // 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 declareStatic
-        errors.push(warnDeclareStaticNotWrappedSync(file, calleeName, `${call.callee.loc?.start?.line}:${call.callee.loc?.start?.column}`));
+        // Not an import specifier, so it's not derive
+        errors.push(warnDeriveFunctionNotWrappedSync(file, calleeName, `${call.callee.loc?.start?.line}:${call.callee.loc?.start?.column}`));
         return null;
     }
     // --- Validate Arguments --- //
@@ -186,7 +187,7 @@ function getDeclareStaticVariants(call, tPath, file, parsingOptions, errors) {
     const arg = call.arguments[0];
     if (!t.isExpression(arg))
         return null;
-    // Handle await expression: declareStatic(await time())
+    // Handle await expression: derive(await time())
     if (t.isAwaitExpression(arg)) {
         // Resolve the inner call's possible string outcomes
         return resolveCallStringVariants(arg.argument, tPath, file, parsingOptions, errors);
@@ -195,29 +196,7 @@ function getDeclareStaticVariants(call, tPath, file, parsingOptions, errors) {
     return resolveCallStringVariants(arg, tPath, file, parsingOptions, errors);
 }
 function resolveCallStringVariants(expression, tPath, file, parsingOptions, errors) {
-    const results = new Set();
-    // // Handle inline arrow functions: declareStatic((() => "day")())
-    // if (
-    //   t.isCallExpression(expression) &&
-    //   t.isParenthesizedExpression(expression.callee) &&
-    //   t.isArrowFunctionExpression(expression.callee.expression)
-    // ) {
-    //   const body = expression.callee.expression.body;
-    //   if (t.isStringLiteral(body)) {
-    //     results.add(body.value);
-    //   } else if (t.isConditionalExpression(body)) {
-    //     collectConditionalStringVariants(body, results);
-    //   }
-    //   return results.size ? [...results] : null;
-    // }
-    // // Handle explicit conditional expression call:
-    // // declareStatic(cond ? "day" : "night")
-    // // TODO: this makes no sense
-    // if (t.isConditionalExpression(expression)) {
-    //   collectConditionalStringVariants(expression, results);
-    //   return results.size ? [...results] : null;
-    // }
-    // Handle function identifier calls: declareStatic(time())
+    // Handle function identifier calls: derive(time())
     if (t.isCallExpression(expression) && t.isIdentifier(expression.callee)) {
         const functionName = expression.callee.name;
         // Use Binding to resolve the function
@@ -267,7 +246,7 @@ function resolveCallStringVariants(expression, tPath, file, parsingOptions, erro
             return null;
         }
     }
-    // If we get here: analyze this call statically
+    // If we get here: analyze this call as derivable (statically analyzable)
     const node = parseStringExpression(expression, tPath, file, parsingOptions);
     if (node) {
         return nodeToStrings(node);
@@ -521,7 +500,7 @@ function resolveFunctionInFile(filePath, functionName, parsingOptions, errors) {
     }
     catch (error) {
         // File read or parse error - return null
-        errors.push(warnDeclareStaticNoResultsSync(filePath, functionName, 'file read/parse error: ' + error));
+        errors.push(warnDeriveFunctionNoResultsSync(filePath, functionName, 'file read/parse error: ' + error));
         result = null;
     }
     // Cache the result

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

@@ -3,7 +3,7 @@ import { buildImportMap } from './buildImportMap.js';
 import { resolveImportPath } from './resolveImportPath.js';
 import { parse } from '@babel/parser';
 import fs from 'node:fs';
-import { warnDeclareStaticNoResultsSync, warnFunctionNotFoundSync, warnInvalidDeclareVarNameSync, } from '../../../console/index.js';
+import { warnDeriveFunctionNoResultsSync, warnFunctionNotFoundSync, warnInvalidDeclareVarNameSync, } from '../../../console/index.js';
 import traverseModule from '@babel/traverse';
 import { DECLARE_VAR_FUNCTION } from '../../jsx/utils/constants.js';
 import { GT_LIBRARIES } from '../../../types/libraries.js';
@@ -470,7 +470,7 @@ function resolveFunctionInFile(filePath, functionName, parsingOptions, warnings)
     }
     catch (error) {
         // File read or parse error - return null
-        warnings.add(warnDeclareStaticNoResultsSync(filePath, functionName, 'file read/parse error: ' + error));
+        warnings.add(warnDeriveFunctionNoResultsSync(filePath, functionName, 'file read/parse error: ' + error));
         result = null;
     }
     // Cache the result

package/dist/react/jsx/utils/stringParsing/processTranslationCall/{handleStaticTranslationCall.d.ts → handleDeriveTranslationCall.d.ts}

@@ -4,7 +4,7 @@ import { ParsingConfig } from '../types.js';
 import { ParsingOutput } from '../types.js';
 import { InlineMetadata } from './extractStringEntryMetadata.js';
 /**
- * For the processTranslationCall function, this function handles the case where a string with declareStatic is used.
+ * For the processTranslationCall function, this function handles the case where a string with derive is used.
  * @param arg - The argument to parse
  * @param metadata - The metadata to use
  * @param tPath - The path to the argument
@@ -12,7 +12,7 @@ import { InlineMetadata } from './extractStringEntryMetadata.js';
  * @param output - The output to use
  * @param index - Current index in array of strings being extracted
  */
-export declare function handleStaticTranslationCall({ arg, metadata, tPath, config, output, index, }: {
+export declare function handleDeriveTranslationCall({ arg, metadata, tPath, config, output, index, }: {
     arg: t.Expression;
     metadata: InlineMetadata;
     tPath: NodePath;

package/dist/react/jsx/utils/stringParsing/processTranslationCall/{handleStaticTranslationCall.js → handleDeriveTranslationCall.js}

@@ -1,4 +1,4 @@
-import { handleStaticExpression } from '../../parseDeclareStatic.js';
+import { handleDeriveExpression } from '../../parseDerive.js';
 import { nodeToStrings } from '../../parseString.js';
 import { indexVars } from 'generaltranslation/internal';
 import { isValidIcu } from '../../../evaluateJsx.js';
@@ -8,7 +8,7 @@ import { randomUUID } from 'node:crypto';
 // Handle CommonJS/ESM interop
 const generate = generateModule.default || generateModule;
 /**
- * For the processTranslationCall function, this function handles the case where a string with declareStatic is used.
+ * For the processTranslationCall function, this function handles the case where a string with derive is used.
  * @param arg - The argument to parse
  * @param metadata - The metadata to use
  * @param tPath - The path to the argument
@@ -16,9 +16,9 @@ const generate = generateModule.default || generateModule;
  * @param output - The output to use
  * @param index - Current index in array of strings being extracted
  */
-export function handleStaticTranslationCall({ arg, metadata, tPath, config, output, index, }) {
-    // parse static expression
-    const result = handleStaticExpression(arg, tPath, config.file, config.parsingOptions, output.errors);
+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}`));
@@ -35,7 +35,7 @@ export function handleStaticTranslationCall({ arg, metadata, tPath, config, outp
             }
         }
     }
-    const temporaryStaticId = `static-temp-id-${randomUUID()}`;
+    const temporaryDeriveId = `derive-temp-id-${randomUUID()}`;
     for (const string of strings) {
         output.updates.push({
             dataFormat: 'ICU',
@@ -44,7 +44,7 @@ export function handleStaticTranslationCall({ arg, metadata, tPath, config, outp
                 ...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: temporaryStaticId,
+                staticId: temporaryDeriveId,
             },
         });
     }

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

@@ -9,7 +9,7 @@ import { ParsingOutput } from '../types.js';
  * - String literals: t('hello')
  * - Template literals without expressions: t(`hello`)
  * - Metadata extraction from options object
- * - Error reporting for non-static expressions and template literals with expressions
+ * - Error reporting for non-derivable expressions and template literals with expressions
  *
  * @param tPath - The path to the translation call
  * @param config - The configuration to use

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

@@ -9,7 +9,7 @@ import { SURROUNDING_LINE_COUNT } from '../../../../../utils/constants.js';
  * - String literals: t('hello')
  * - Template literals without expressions: t(`hello`)
  * - Metadata extraction from options object
- * - Error reporting for non-static expressions and template literals with expressions
+ * - Error reporting for non-derivable expressions and template literals with expressions
  *
  * @param tPath - The path to the translation call
  * @param config - The configuration to use

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

@@ -1,5 +1,5 @@
 import { isStaticExpression } from '../../../evaluateJsx.js';
-import { handleStaticTranslationCall } from './handleStaticTranslationCall.js';
+import { handleDeriveTranslationCall } from './handleDeriveTranslationCall.js';
 import { handleLiteralTranslationCall } from './handleLiteralTranslationCall.js';
 import { handleInvalidTranslationCall } from './handleInvalidTranslationCall.js';
 import * as t from '@babel/types';
@@ -36,8 +36,8 @@ export function routeTranslationCall({ tPath, config, output, arg, metadata, ind
     else if (!config.ignoreDynamicContent &&
         t.isExpression(arg) &&
         !isStaticExpression(arg).isStatic) {
-        // handle static translation call
-        handleStaticTranslationCall({
+        // handle derive translation call
+        handleDeriveTranslationCall({
             arg,
             metadata,
             tPath,

package/dist/react/jsx/wrapJsx.js

@@ -236,7 +236,7 @@ function wrapJsxExpression(node, options, isMeaningful, mark) {
         }
     }
     const staticCheck = isStaticExpression(expression);
-    // If the expression is not static or if it's already wrapped in T,
+    // If the expression is not derivable or if it's already wrapped in T,
     // wrap with Var
     if (!staticCheck.isStatic) {
         return {
@@ -245,7 +245,7 @@ function wrapJsxExpression(node, options, isMeaningful, mark) {
             wrappedInT: false,
         };
     }
-    // If it's a static expression, check if it's meaningful
+    // If it's a derivable expression, check if it's meaningful
     return {
         node,
         hasMeaningfulContent: false,
@@ -294,7 +294,7 @@ export function wrapJsxElement(node, options, isMeaningful, mark) {
                     hasMeaningfulContent || result.hasMeaningfulContent;
                 // Expressions are never meaningful because they will either:
                 // 1. be sub-wrapped in a T (if they contain meaningful content)
-                // 2. be wrapped in a Var (if they are not static)
+                // 2. be wrapped in a Var (if they are not marked as derivable)
                 return result.node;
             }
             const isMeaningfulVal = isMeaningful(child);

package/dist/react/parse/createInlineUpdates.js

@@ -7,7 +7,7 @@ import { matchFiles } from '../../fs/matchFiles.js';
 import { DEFAULT_SRC_PATTERNS } from '../../config/generateSettings.js';
 import { getPathsAndAliases } from '../jsx/utils/getPathsAndAliases.js';
 import { GT_LIBRARIES_UPSTREAM, REACT_LIBRARIES, } from '../../types/libraries.js';
-import { calculateHashes, dedupeUpdates, linkStaticUpdates, } from '../../extraction/postProcess.js';
+import { calculateHashes, dedupeUpdates, linkDeriveUpdates, } from '../../extraction/postProcess.js';
 export async function createInlineUpdates(pkg, validate, filePatterns, parsingOptions, includeSourceCodeContext = false) {
     const updates = [];
     const errors = [];
@@ -69,7 +69,7 @@ export async function createInlineUpdates(pkg, validate, filePatterns, parsingOp
     // Post processing steps:
     await calculateHashes(updates);
     dedupeUpdates(updates);
-    linkStaticUpdates(updates);
+    linkDeriveUpdates(updates);
     return { updates, errors, warnings: [...warnings] };
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gt",
-  "version": "2.10.5",
+  "version": "2.10.6",
   "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.2",
-    "generaltranslation": "8.1.16",
+    "@generaltranslation/python-extractor": "0.1.3",
+    "generaltranslation": "8.1.17",
     "gt-remark": "1.0.5"
   },
   "devDependencies": {