gtx-cli 2.5.35 → 2.5.36

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # gtx-cli
 
+## 2.5.36
+
+### Patch Changes
+
+- [#806](https://github.com/generaltranslation/gt/pull/806) [`d59dd40`](https://github.com/generaltranslation/gt/commit/d59dd40e7b042e2bb4e718f17f3b2e764165151f) Thanks [@archie-mckenzie](https://github.com/archie-mckenzie)! - feat: declareStatic()
+
+- Updated dependencies [[`d59dd40`](https://github.com/generaltranslation/gt/commit/d59dd40e7b042e2bb4e718f17f3b2e764165151f)]:
+  - generaltranslation@8.1.4
+
 ## 2.5.35
 
 ### Patch Changes

package/dist/console/formatting.d.ts

@@ -0,0 +1 @@
+export declare function formatCodeClamp(code: string): string;

package/dist/console/formatting.js

@@ -0,0 +1,7 @@
+const MAX_CODE_GEN_LENGTH = 100;
+export function formatCodeClamp(code) {
+    if (code.length <= MAX_CODE_GEN_LENGTH) {
+        return code;
+    }
+    return `${code.slice(0, MAX_CODE_GEN_LENGTH)}...`;
+}

package/dist/console/index.d.ts

@@ -14,11 +14,13 @@ export declare const warnAsyncUseGT: (file: string, location?: string) => string
 export declare const warnSyncGetGT: (file: string, location?: string) => string;
 export declare const warnTernarySync: (file: string, location?: string) => string;
 export declare const withLocation: (file: string, message: string, location?: string) => string;
-export declare const warnInvalidStaticChildSync: (file: string, location?: string) => string;
 export declare const warnFunctionNotFoundSync: (file: string, functionName: string, location?: string) => string;
+export declare const 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 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 noLocalesError = "No locales found! Please provide a list of locales to translate to, or specify them in your gt.config.json file.";
 export declare const noDefaultLocaleError = "No default locale found! Please provide a default locale, or specify it in your gt.config.json file.";
 export declare const noFilesError = "Incorrect or missing files configuration! Please make sure your files are configured correctly in your gt.config.json file.";

package/dist/console/index.js

@@ -1,7 +1,9 @@
 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}`;
 // Synchronous wrappers for backward compatibility
 export const warnApiKeyInConfigSync = (optionsFilepath) => `${colorizeFilepath(optionsFilepath)}: Your API key is exposed! Please remove it from the file and include it as an environment variable.`;
 export const warnVariablePropSync = (file, attrName, value, location) => withLocation(file, `${colorizeComponent('<T>')} component has dynamic attribute ${colorizeIdString(attrName)} with value: ${colorizeContent(value)}. Change ${colorizeIdString(attrName)} to ensure this content is translated.`, location);
@@ -20,13 +22,15 @@ export const warnAsyncUseGT = (file, location) => withLocation(file, `Found useG
 export const warnSyncGetGT = (file, location) => withLocation(file, `Found getGT() in a synchronous function. Use useGT() instead, or make the function async.`, location);
 export const warnTernarySync = (file, location) => withLocation(file, 'Found ternary expression. A Branch component may be more appropriate here.', location);
 export const withLocation = (file, message, location) => `${colorizeFilepath(file)}${location ? ` (${colorizeLine(location)})` : ''}: ${message}`;
-export const warnInvalidStaticChildSync = (file, location) => withLocation(file, 'Found invalid <Static> invocation. Children must be an expression container with a function invocation. Callee must be a single identifier. (Example: <T> <Static> {getSubject()} </Static> </T>)', location);
 export const warnFunctionNotFoundSync = (file, functionName, location) => withLocation(file, `Function ${colorizeFunctionName(functionName)} definition could not be resolved. This might affect translation resolution for this ${colorizeComponent('<T>')} component.`, location);
+export const warnInvalidDeclareVarNameSync = (file, value, location) => withLocation(file, `Found invalid declareVar() $name tag. Must be a static 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.
 Example: ${colorizeContent(`const ${colorizeFunctionName(functionName)} = () => { ... }`)}
 Invalid: ${colorizeContent(`const ${colorizeFunctionName(functionName)} = [() => { ... }][0]`)}`), 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);
 // Re-export error messages
 export const noLocalesError = `No locales found! Please provide a list of locales to translate to, or specify them in your gt.config.json file.`;
 export const noDefaultLocaleError = `No default locale found! Please provide a default locale, or specify it in your gt.config.json file.`;

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const PACKAGE_VERSION = "2.5.35";
+export declare const PACKAGE_VERSION = "2.5.36";

package/dist/generated/version.js

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

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

@@ -1,4 +1,6 @@
-export declare const MSG_TRANSLATION_HOOK = "msg";
+export declare const DECLARE_VAR_FUNCTION = "declareVar";
+export declare const DECLARE_STATIC_FUNCTION = "declareStatic";
+export declare const MSG_TRANSLATION_FUNCTION = "msg";
 export declare const INLINE_TRANSLATION_HOOK = "useGT";
 export declare const INLINE_TRANSLATION_HOOK_ASYNC = "getGT";
 export declare const INLINE_MESSAGE_HOOK = "useMessages";

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

@@ -1,4 +1,6 @@
-export const MSG_TRANSLATION_HOOK = 'msg';
+export const DECLARE_VAR_FUNCTION = 'declareVar';
+export const DECLARE_STATIC_FUNCTION = 'declareStatic';
+export const MSG_TRANSLATION_FUNCTION = 'msg';
 export const INLINE_TRANSLATION_HOOK = 'useGT';
 export const INLINE_TRANSLATION_HOOK_ASYNC = 'getGT';
 export const INLINE_MESSAGE_HOOK = 'useMessages';
@@ -11,7 +13,9 @@ export const GT_TRANSLATION_FUNCS = [
     INLINE_TRANSLATION_HOOK_ASYNC,
     INLINE_MESSAGE_HOOK,
     INLINE_MESSAGE_HOOK_ASYNC,
-    MSG_TRANSLATION_HOOK,
+    MSG_TRANSLATION_FUNCTION,
+    DECLARE_VAR_FUNCTION,
+    DECLARE_STATIC_FUNCTION,
     TRANSLATION_COMPONENT,
     STATIC_COMPONENT,
     'Var',
@@ -63,11 +67,17 @@ export const GT_LIBRARIES_UPSTREAM = {
         'gt-react',
         'gt-next',
     ],
-    'gt-react': ['gt-i18n', '@generaltranslation/react-core', 'gt-react'],
+    'gt-react': [
+        'gt-i18n',
+        '@generaltranslation/react-core',
+        'gt-react',
+        'gt-react-native', // allow for cross-library compatibility (gt-react/gt-react-native only)
+    ],
     'gt-react-native': [
         'gt-i18n',
         '@generaltranslation/react-core',
         'gt-react-native',
+        'gt-react', // allow for cross-library compatibility (gt-react/gt-react-native only)
     ],
     '@generaltranslation/react-core': [
         'gt-i18n',

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

@@ -0,0 +1,9 @@
+import * as t from '@babel/types';
+/**
+ * Get the callee name from an expression: ... = useGT();
+ * Rule of thumb, only call on expressions with parentheses
+ */
+export declare function getCalleeNameFromExpression(expr: t.Expression): {
+    namespaceName: string | null;
+    functionName: string | null;
+};

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

@@ -0,0 +1,32 @@
+import * as t from '@babel/types';
+/**
+ * Get the callee name from an expression: ... = useGT();
+ * Rule of thumb, only call on expressions with parentheses
+ */
+export function getCalleeNameFromExpression(expr) {
+    // If its an await expression, unwrap it
+    if (t.isAwaitExpression(expr)) {
+        return getCalleeNameFromExpression(expr.argument);
+    }
+    // Check that this is a call expression eg: func()
+    if (!t.isCallExpression(expr)) {
+        return { namespaceName: null, functionName: null };
+    }
+    // Get the callee name
+    const calleeName = expr.callee;
+    // Simple case: ... = useGT();
+    if (t.isIdentifier(calleeName)) {
+        return { namespaceName: null, functionName: calleeName.name };
+    }
+    // Member expression: ... = GT.useGT();
+    if (t.isMemberExpression(calleeName)) {
+        if (t.isIdentifier(calleeName.object) &&
+            t.isIdentifier(calleeName.property)) {
+            return {
+                namespaceName: calleeName.object.name,
+                functionName: calleeName.property.name,
+            };
+        }
+    }
+    return { namespaceName: null, functionName: null };
+}

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

@@ -1,5 +1,5 @@
 import traverseModule from '@babel/traverse';
-import { GT_TRANSLATION_FUNCS, INLINE_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK_ASYNC, INLINE_MESSAGE_HOOK, INLINE_MESSAGE_HOOK_ASYNC, MSG_TRANSLATION_HOOK, TRANSLATION_COMPONENT, } from '../../jsx/utils/constants.js';
+import { GT_TRANSLATION_FUNCS, INLINE_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK_ASYNC, INLINE_MESSAGE_HOOK, INLINE_MESSAGE_HOOK_ASYNC, MSG_TRANSLATION_FUNCTION, TRANSLATION_COMPONENT, } from '../../jsx/utils/constants.js';
 import { extractImportName } from './parseAst.js';
 // Handle CommonJS/ESM interop
 const traverse = traverseModule.default || traverseModule;
@@ -23,7 +23,7 @@ export function getPathsAndAliases(ast, pkgs) {
                         name.original === INLINE_TRANSLATION_HOOK_ASYNC ||
                         name.original === INLINE_MESSAGE_HOOK ||
                         name.original === INLINE_MESSAGE_HOOK_ASYNC ||
-                        name.original === MSG_TRANSLATION_HOOK) {
+                        name.original === MSG_TRANSLATION_FUNCTION) {
                         inlineTranslationPaths.push({
                             localName: name.local,
                             path,
@@ -61,7 +61,7 @@ export function getPathsAndAliases(ast, pkgs) {
                                 name.original === INLINE_TRANSLATION_HOOK_ASYNC ||
                                 name.original === INLINE_MESSAGE_HOOK ||
                                 name.original === INLINE_MESSAGE_HOOK_ASYNC ||
-                                name.original === MSG_TRANSLATION_HOOK) {
+                                name.original === MSG_TRANSLATION_FUNCTION) {
                                 inlineTranslationPaths.push({
                                     localName: name.local,
                                     path: parentPath,

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

@@ -120,8 +120,6 @@ export function handleChildrenWhitespace(currentTree, parentNodeType = undefined
                     newChildren.push(newElement);
                     break;
                 case 'multiplication':
-                    // I dont think this case is possible, at least in the array case
-                    // Can only be child of element or multiplication nodes
                     newChildren.push({
                         nodeType: 'multiplication',
                         branches: handleChildrenWhitespace(child.branches, 'multiplication'),

package/dist/react/jsx/utils/jsxParsing/parseJsx.d.ts

@@ -3,7 +3,7 @@ import * as t from '@babel/types';
 import { NodePath } from '@babel/traverse';
 import { ParsingConfigOptions } from '../../../../types/parsing.js';
 import traverseModule from '@babel/traverse';
-import { JsxTree } from './types.js';
+import { MultiplicationNode, JsxTree } from './types.js';
 import { GTLibrary } from '../constants.js';
 /**
  * Entry point for JSX parsing
@@ -31,12 +31,11 @@ export declare function parseTranslationComponent({ originalName, importAliases,
  * @param insideT - Whether the current node is inside a <T> component
  * @returns The built JSX tree
  */
-export declare function buildJSXTree({ importAliases, node, unwrappedExpressions, visited, callStack, updates, errors, warnings, file, insideT, parsingOptions, scopeNode, importedFunctionsMap, pkgs, }: {
+export declare function buildJSXTree({ importAliases, node, unwrappedExpressions, inStatic, visited, callStack, updates, errors, warnings, file, insideT, parsingOptions, scopeNode, importedFunctionsMap, pkgs, helperPath, }: {
     importAliases: Record<string, string>;
     node: any;
     callStack: string[];
     unwrappedExpressions: string[];
-    visited: Set<string> | null;
     updates: Updates;
     errors: string[];
     warnings: Set<string>;
@@ -46,7 +45,10 @@ export declare function buildJSXTree({ importAliases, node, unwrappedExpressions
     scopeNode: NodePath;
     importedFunctionsMap: Map<string, string>;
     pkgs: GTLibrary[];
-}): JsxTree;
+    inStatic: boolean;
+    visited: Set<string> | null;
+    helperPath: NodePath;
+}): JsxTree | MultiplicationNode;
 export declare function parseJSXElement({ importAliases, node, originalName, pkgs, updates, errors, warnings, file, parsingOptions, scopeNode, importedFunctionsMap, }: {
     importAliases: Record<string, string>;
     node: t.JSXElement;