gtx-cli 2.5.23 → 2.5.25

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # gtx-cli
 
+## 2.5.25
+
+### Patch Changes
+
+- [#876](https://github.com/generaltranslation/gt/pull/876) [`28bd6d5`](https://github.com/generaltranslation/gt/commit/28bd6d5f1ed50658da2e3adc5b59a40804b00b02) Thanks [@fernando-aviles](https://github.com/fernando-aviles)! - Adding experimental alphabetical sort for JSONs with locales as keys
+
+## 2.5.24
+
+### Patch Changes
+
+- [#860](https://github.com/generaltranslation/gt/pull/860) [`37bac4c`](https://github.com/generaltranslation/gt/commit/37bac4ce11689a2f729efbcb2e052205447a7f71) Thanks [@ErnestM1234](https://github.com/ErnestM1234)! - chore: support for max char
+
+- Updated dependencies [[`37bac4c`](https://github.com/generaltranslation/gt/commit/37bac4ce11689a2f729efbcb2e052205447a7f71)]:
+  - generaltranslation@8.1.1
+
 ## 2.5.23
 
 ### Patch Changes

package/dist/console/index.d.ts

@@ -6,6 +6,7 @@ export declare const warnHasUnwrappedExpressionSync: (file: string, unwrappedExp
 export declare const warnFailedToConstructJsxTreeSync: (file: string, code: string, location?: string) => string;
 export declare const warnNestedTComponent: (file: string, location?: string) => string;
 export declare const warnNonStaticExpressionSync: (file: string, attrName: string, value: string, location?: string) => string;
+export declare const warnInvalidMaxCharsSync: (file: string, value: string, location?: string) => string;
 export declare const warnInvalidIcuSync: (file: string, value: string, error: string, location?: string) => string;
 export declare const warnTemplateLiteralSync: (file: string, value: string, location?: string) => string;
 export declare const warnNonStringSync: (file: string, value: string, location?: string) => string;

package/dist/console/index.js

@@ -12,6 +12,7 @@ export const warnHasUnwrappedExpressionSync = (file, unwrappedExpressions, id, l
 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);
 export const warnNonStaticExpressionSync = (file, attrName, value, location) => withLocation(file, `Found non-static expression for attribute ${colorizeIdString(attrName)}: ${colorizeContent(value)}. Change "${colorizeIdString(attrName)}" to ensure this content is translated.`, location);
+export const warnInvalidMaxCharsSync = (file, value, location) => withLocation(file, `Found invalid maxChars value: ${colorizeContent(value)}. Change the value to a valid number to ensure this content is translated.`, location);
 export const warnInvalidIcuSync = (file, value, error, location) => withWillErrorInNextVersion(withLocation(file, `Found invalid ICU string: ${colorizeContent(value)}. Change the value to a valid ICU to ensure this content is translated. Error message: ${error}.`, location));
 export const warnTemplateLiteralSync = (file, value, location) => withLocation(file, `Found template literal with quasis (${colorizeContent(value)}). Change the template literal to a string to ensure this content is translated.`, location);
 export const warnNonStringSync = (file, value, location) => withLocation(file, `Found non-string literal (${colorizeContent(value)}). Change the value to a string literal to ensure this content is translated.`, location);

package/dist/formats/json/mergeJson.js

@@ -207,16 +207,10 @@ export function mergeJson(originalContent, inputPath, options, targets, defaultL
     return [JSON.stringify(mergedJson, null, 2)];
 }
 function sortByLocaleOrder(items, sourceObjectOptions, localeOrder, sourceObjectPointer, defaultLocale) {
-    if (sourceObjectOptions.experimentalSort !== 'locales' ||
-        !localeOrder.length ||
-        !sourceObjectOptions.key) {
+    const sortMode = sourceObjectOptions.experimentalSort;
+    if (!sortMode || !sourceObjectOptions.key) {
         return items;
     }
-    const orderedLocaleList = [
-        defaultLocale,
-        ...localeOrder.filter((locale) => locale !== defaultLocale),
-    ];
-    const localeOrderValues = orderedLocaleList.map((locale) => getIdentifyingLocaleProperty(locale, sourceObjectPointer, sourceObjectOptions));
     const itemsWithLocale = items.map((item) => {
         let localeValue;
         try {
@@ -237,21 +231,56 @@ function sortByLocaleOrder(items, sourceObjectOptions, localeOrder, sourceObject
         }
         return { item, localeValue };
     });
-    const orderedItems = [];
-    const remainingItems = [...itemsWithLocale];
-    for (const localeValue of localeOrderValues) {
-        for (let i = 0; i < remainingItems.length;) {
-            const entry = remainingItems[i];
-            if (entry.localeValue === localeValue) {
-                orderedItems.push(entry.item);
-                remainingItems.splice(i, 1);
+    if (sortMode === 'locales') {
+        if (!localeOrder.length) {
+            return items;
+        }
+        const orderedLocaleList = [
+            defaultLocale,
+            ...localeOrder.filter((locale) => locale !== defaultLocale),
+        ];
+        const localeOrderValues = orderedLocaleList.map((locale) => getIdentifyingLocaleProperty(locale, sourceObjectPointer, sourceObjectOptions));
+        const orderedItems = [];
+        const remainingItems = [...itemsWithLocale];
+        for (const localeValue of localeOrderValues) {
+            for (let i = 0; i < remainingItems.length;) {
+                const entry = remainingItems[i];
+                if (entry.localeValue === localeValue) {
+                    orderedItems.push(entry.item);
+                    remainingItems.splice(i, 1);
+                    continue;
+                }
+                i += 1;
+            }
+        }
+        remainingItems.forEach((entry) => orderedItems.push(entry.item));
+        return orderedItems;
+    }
+    if (sortMode === 'localesAlphabetical') {
+        const defaultLocaleValue = getIdentifyingLocaleProperty(defaultLocale, sourceObjectPointer, sourceObjectOptions);
+        const defaultItems = [];
+        const sortableItems = [];
+        const remainingItems = [];
+        for (const entry of itemsWithLocale) {
+            if (entry.localeValue === defaultLocaleValue) {
+                defaultItems.push(entry);
+                continue;
+            }
+            if (entry.localeValue) {
+                sortableItems.push(entry);
                 continue;
             }
-            i += 1;
+            remainingItems.push(entry);
         }
+        sortableItems.sort((a, b) => {
+            if (!a.localeValue || !b.localeValue) {
+                return 0;
+            }
+            return a.localeValue.localeCompare(b.localeValue);
+        });
+        return [...defaultItems, ...sortableItems, ...remainingItems].map((entry) => entry.item);
     }
-    remainingItems.forEach((entry) => orderedItems.push(entry.item));
-    return orderedItems;
+    return items;
 }
 /**
  * Apply transformations to the sourceItem in-place

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

@@ -7,8 +7,8 @@ export declare const TRANSLATION_COMPONENT = "T";
 export declare const STATIC_COMPONENT = "Static";
 export declare const GT_TRANSLATION_FUNCS: string[];
 export declare const VARIABLE_COMPONENTS: string[];
-export declare const GT_ATTRIBUTES_WITH_SUGAR: string[];
-export declare const GT_ATTRIBUTES: string[];
+export declare const GT_ATTRIBUTES_WITH_SUGAR: readonly ["$id", "$context", "$maxChars"];
+export declare const GT_ATTRIBUTES: readonly ["id", "context", "maxChars", "$id", "$context", "$maxChars"];
 export declare function mapAttributeName(attrName: string): string;
 export declare const GT_LIBRARIES: readonly ["gt-react", "gt-next", "gt-react-native", "gt-i18n", "@generaltranslation/react-core"];
 export type GTLibrary = (typeof GT_LIBRARIES)[number];

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

@@ -29,13 +29,24 @@ export const VARIABLE_COMPONENTS = [
     'Num',
     STATIC_COMPONENT,
 ];
-export const GT_ATTRIBUTES_WITH_SUGAR = ['$id', '$context'];
-export const GT_ATTRIBUTES = ['id', 'context', ...GT_ATTRIBUTES_WITH_SUGAR];
+export const GT_ATTRIBUTES_WITH_SUGAR = [
+    '$id',
+    '$context',
+    '$maxChars',
+];
+export const GT_ATTRIBUTES = [
+    'id',
+    'context',
+    'maxChars',
+    ...GT_ATTRIBUTES_WITH_SUGAR,
+];
 export function mapAttributeName(attrName) {
     if (attrName === '$id')
         return 'id';
     if (attrName === '$context')
         return 'context';
+    if (attrName === '$maxChars')
+        return 'maxChars';
     return attrName;
 }
 export const GT_LIBRARIES = [

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

@@ -0,0 +1,7 @@
+import * as t from '@babel/types';
+/**
+ * Given an expression, return true if it is a number literal
+ * @param expr - The expression to check
+ * @returns True if the expression is a number literal, false otherwise
+ */
+export declare function isNumberLiteral(expr: t.Expression): boolean;

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

@@ -0,0 +1,13 @@
+import * as t from '@babel/types';
+/**
+ * Given an expression, return true if it is a number literal
+ * @param expr - The expression to check
+ * @returns True if the expression is a number literal, false otherwise
+ */
+export function isNumberLiteral(expr) {
+    if (t.isUnaryExpression(expr)) {
+        return (isNumberLiteral(expr.argument) &&
+            (expr.operator === '-' || expr.operator === '+'));
+    }
+    return t.isNumericLiteral(expr);
+}

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

@@ -4,7 +4,8 @@ import generateModule from '@babel/generator';
 const generate = generateModule.default || generateModule;
 import { GT_ATTRIBUTES, mapAttributeName } from '../constants.js';
 import { isStaticExpression } from '../../evaluateJsx.js';
-import { warnVariablePropSync } from '../../../../console/index.js';
+import { warnInvalidMaxCharsSync, warnVariablePropSync, } from '../../../../console/index.js';
+import { isNumberLiteral } from '../isNumberLiteral.js';
 // Parse the props of a <T> component
 export function parseTProps({ openingElement, metadata, componentErrors, file, }) {
     openingElement.attributes.forEach((attr) => {
@@ -22,7 +23,7 @@ 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 props
+                // Only check for static expressions on id and context and maxChars props
                 if (GT_ATTRIBUTES.includes(attrName)) {
                     const staticAnalysis = isStaticExpression(expr);
                     if (!staticAnalysis.isStatic) {
@@ -30,7 +31,23 @@ export function parseTProps({ openingElement, metadata, componentErrors, file, }
                     }
                     // Use the static value if available
                     if (staticAnalysis.isStatic && staticAnalysis.value !== undefined) {
-                        metadata[mapAttributeName(attrName)] = staticAnalysis.value;
+                        // Check for invalid maxChars values
+                        if (attrName === '$maxChars' || attrName === 'maxChars') {
+                            if (typeof staticAnalysis.value === 'string' &&
+                                (isNaN(Number(staticAnalysis.value)) ||
+                                    (t.isExpression(expr) && !isNumberLiteral(expr)) ||
+                                    !Number.isInteger(Number(staticAnalysis.value)))) {
+                                componentErrors.push(warnInvalidMaxCharsSync(file, code, `${expr.loc?.start?.line}:${expr.loc?.start?.column}`));
+                            }
+                            else {
+                                // Add the maxChars value to the metadata
+                                metadata[mapAttributeName(attrName)] = Math.abs(Number(staticAnalysis.value));
+                            }
+                        }
+                        else {
+                            // Add the $context or $id or other attributes value to the metadata
+                            metadata[mapAttributeName(attrName)] = staticAnalysis.value;
+                        }
                     }
                     else {
                         // Only store the code if we couldn't extract a static value

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

@@ -1,7 +1,7 @@
 import * as t from '@babel/types';
 import { isStaticExpression, isValidIcu } from '../evaluateJsx.js';
 import { GT_ATTRIBUTES_WITH_SUGAR, MSG_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK_ASYNC, mapAttributeName, INLINE_MESSAGE_HOOK, INLINE_MESSAGE_HOOK_ASYNC, } from './constants.js';
-import { warnNonStaticExpressionSync, warnNonStringSync, warnTemplateLiteralSync, warnAsyncUseGT, warnSyncGetGT, warnInvalidIcuSync, } from '../../../console/index.js';
+import { warnNonStaticExpressionSync, warnNonStringSync, warnTemplateLiteralSync, warnAsyncUseGT, warnSyncGetGT, warnInvalidIcuSync, warnInvalidMaxCharsSync, } from '../../../console/index.js';
 import generateModule from '@babel/generator';
 import traverseModule from '@babel/traverse';
 // Handle CommonJS/ESM interop
@@ -11,6 +11,7 @@ import fs from 'node:fs';
 import { parse } from '@babel/parser';
 import { resolveImportPath } from './resolveImportPath.js';
 import { buildImportMap } from './buildImportMap.js';
+import { isNumberLiteral } from './isNumberLiteral.js';
 /**
  * Cache for resolved import paths to avoid redundant I/O operations.
  * Key: `${currentFile}::${importPath}`
@@ -69,9 +70,26 @@ function processTranslationCall(tPath, updates, errors, warnings, file, ignoreAd
                             if (!result.isStatic) {
                                 errors.push(warnNonStaticExpressionSync(file, attribute, generate(prop.value).code, `${prop.loc?.start?.line}:${prop.loc?.start?.column}`));
                             }
-                            if (result.isStatic && result.value && !ignoreAdditionalData) {
-                                // Map $id and $context to id and context
-                                metadata[mapAttributeName(attribute)] = result.value;
+                            if (result.isStatic &&
+                                result.value != null &&
+                                !ignoreAdditionalData) {
+                                const mappedKey = mapAttributeName(attribute);
+                                if (attribute === '$maxChars') {
+                                    if ((typeof result.value === 'string' &&
+                                        (isNaN(Number(result.value)) ||
+                                            !isNumberLiteral(prop.value))) ||
+                                        !Number.isInteger(Number(result.value))) {
+                                        errors.push(warnInvalidMaxCharsSync(file, generate(prop).code, `${prop.loc?.start?.line}:${prop.loc?.start?.column}`));
+                                    }
+                                    else if (typeof result.value === 'string') {
+                                        // Add the maxChars value to the metadata
+                                        metadata[mappedKey] = Math.abs(Number(result.value));
+                                    }
+                                }
+                                else {
+                                    // Add the $context or $id or other attributes value to the metadata
+                                    metadata[mappedKey] = result.value;
+                                }
                             }
                         }
                     }

package/dist/react/parse/createDictionaryUpdates.d.ts

@@ -1,3 +1,3 @@
 import { BuildOptions } from 'esbuild';
 import { Updates } from '../../types/index.js';
-export declare function createDictionaryUpdates(dictionaryPath: string, warnings: string[], esbuildConfig?: BuildOptions): Promise<Updates>;
+export declare function createDictionaryUpdates(dictionaryPath: string, errors: string[], warnings: string[], esbuildConfig?: BuildOptions): Promise<Updates>;

package/dist/react/parse/createDictionaryUpdates.js

@@ -9,9 +9,9 @@ import getEntryAndMetadata from '../utils/getEntryAndMetadata.js';
 import { logger } from '../../console/logger.js';
 import { randomUUID } from 'node:crypto';
 import { isValidIcu } from '../jsx/evaluateJsx.js';
-import { warnInvalidIcuSync } from '../../console/index.js';
+import { warnInvalidIcuSync, warnInvalidMaxCharsSync, } from '../../console/index.js';
 import { exitSync } from '../../console/logging.js';
-export async function createDictionaryUpdates(dictionaryPath, warnings, esbuildConfig) {
+export async function createDictionaryUpdates(dictionaryPath, errors, warnings, esbuildConfig) {
     let dictionary;
     // ---- HANDLE JSON STRING DICTIONARY ----- //
     if (dictionaryPath.endsWith('.json')) {
@@ -54,16 +54,25 @@ export async function createDictionaryUpdates(dictionaryPath, warnings, esbuildC
             warnings.push(warnInvalidIcuSync(dictionaryPath, entry, error ?? 'Unknown error'));
             continue;
         }
+        // Validate maxChars
+        if (props?.$maxChars &&
+            (isNaN(props.$maxChars) || !Number.isInteger(props.$maxChars))) {
+            errors.push(warnInvalidMaxCharsSync(dictionaryPath, String(props.$maxChars), id));
+            continue;
+        }
         // Map $context to context
         const context = props?.$context;
+        const maxChars = props?.$maxChars;
         const metadata = {
             id,
             ...(context && { context }),
+            ...(maxChars != null && { maxChars: Math.abs(maxChars) }),
             // This hash isn't actually used by the GT API, just for consistency sake
             hash: hashSource({
                 source: entry,
                 ...(context && { context }),
                 ...(id && { id }),
+                ...(maxChars != null && { maxChars: Math.abs(maxChars) }),
                 dataFormat: 'ICU',
             }),
         };

package/dist/react/parse/createInlineUpdates.js

@@ -60,11 +60,13 @@ export async function createInlineUpdates(pkg, validate, filePatterns, parsingOp
     }
     // Post-process to add a hash to each update
     await Promise.all(updates.map(async (update) => {
-        const context = update.metadata.context;
         const hash = hashSource({
             source: update.source,
-            ...(context && { context }),
+            ...(update.metadata.context && { context: update.metadata.context }),
             ...(update.metadata.id && { id: update.metadata.id }),
+            ...(update.metadata.maxChars != null && {
+                maxChars: update.metadata.maxChars,
+            }),
             dataFormat: update.dataFormat,
         });
         update.metadata.hash = hash;

package/dist/translation/parse.js

@@ -26,7 +26,7 @@ export async function createUpdates(options, src, sourceDictionary, pkg, validat
         if (sourceDictionary.endsWith('.json')) {
             updates = [
                 ...updates,
-                ...(await createDictionaryUpdates(sourceDictionary, warnings)),
+                ...(await createDictionaryUpdates(sourceDictionary, errors, warnings)),
             ];
         }
         else {
@@ -44,7 +44,7 @@ export async function createUpdates(options, src, sourceDictionary, pkg, validat
             }
             updates = [
                 ...updates,
-                ...(await createDictionaryUpdates(sourceDictionary, warnings, esbuildConfig)),
+                ...(await createDictionaryUpdates(sourceDictionary, errors, warnings, esbuildConfig)),
             ];
         }
     }

package/dist/types/data.d.ts

@@ -1,6 +1,13 @@
 export type Entry = string;
 export type DictionaryMetadata = {
+    $context?: string;
+    $maxChars?: number;
+    $_hash?: string;
+    /** @deprecated use $context instead */
     context?: string;
+    /** @deprecated use $maxChars instead */
+    maxChars?: number;
+    /** @deprecated */
     variablesOptions?: Record<string, any>;
     [key: string]: any;
 };

package/dist/types/index.d.ts

@@ -208,7 +208,7 @@ export type SourceObjectOptions = {
     key?: string;
     localeProperty?: string;
     transform?: TransformOptions;
-    experimentalSort?: 'locales';
+    experimentalSort?: 'locales' | 'localesAlphabetical';
 };
 export type TransformOptions = {
     [transformPath: string]: TransformOption;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtx-cli",
-  "version": "2.5.23",
+  "version": "2.5.25",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [
@@ -104,7 +104,7 @@
     "unified": "^11.0.5",
     "unist-util-visit": "^5.0.0",
     "yaml": "^2.8.0",
-    "generaltranslation": "8.1.0"
+    "generaltranslation": "8.1.1"
   },
   "devDependencies": {
     "@babel/types": "^7.28.4",