gtx-cli 2.6.29 → 2.6.30-alpha.0

package/dist/react/parse/addVitePlugin/utils/addPluginInvocation.js

@@ -1,48 +0,0 @@
-import * as t from '@babel/types';
-import traverseModule from '@babel/traverse';
-// Handle CommonJS/ESM interop
-const traverse = traverseModule.default || traverseModule;
-/**
- * Adds the plugin invocation to the vite config file
- * Naive solution: look for an object with a plugins property only inside of a defineConfig call
- */
-export function addPluginInvocation({ ast, alias, namespaces, }) {
-    let addedPlugin = false;
-    if (namespaces.length === 0 && !alias) {
-        return false;
-    }
-    const pluginInvocation = alias
-        ? t.callExpression(t.identifier(alias), [])
-        : t.callExpression(t.memberExpression(t.identifier(namespaces[0]), t.identifier('vite')), []);
-    traverse(ast, {
-        CallExpression(path) {
-            if (!t.isIdentifier(path.node.callee, { name: 'defineConfig' }) ||
-                !path.node.arguments.length ||
-                !t.isObjectExpression(path.node.arguments[0])) {
-                return;
-            }
-            for (const property of path.node.arguments[0].properties) {
-                if (!t.isObjectProperty(property) || !isPluginsProperty(property))
-                    continue;
-                if (t.isArrayExpression(property.value)) {
-                    // Add to array: [react()] -> [react(), gtCompiler()]
-                    property.value.elements.push(pluginInvocation);
-                    addedPlugin = true;
-                }
-                else {
-                    // Spread the array: someList -> [...someList, gtCompiler()]
-                    property.value = t.arrayExpression([
-                        t.spreadElement(property.value),
-                        pluginInvocation,
-                    ]);
-                    addedPlugin = true;
-                }
-            }
-        },
-    });
-    return addedPlugin;
-}
-function isPluginsProperty(node) {
-    return (t.isIdentifier(node.key, { name: 'plugins' }) ||
-        t.isStringLiteral(node.key, { value: 'plugins' }));
-}

package/dist/react/parse/addVitePlugin/utils/checkCompilerImport.d.ts

@@ -1,15 +0,0 @@
-import { ParseResult } from '@babel/parser';
-import * as t from '@babel/types';
-export interface CheckCompilerImportResult {
-    hasCompilerImport: boolean;
-    alias: string | null;
-    namespaces: string[];
-}
-/**
- * Given the vite config file ast, checks if the @generaltranslation/compiler package is imported.
- * If it is imported, capture any aliases or namespace.
- *
- * Does not handle:
- * - Nested expressions
- */
-export declare function checkCompilerImport(ast: ParseResult<t.File>): CheckCompilerImportResult;

package/dist/react/parse/addVitePlugin/utils/checkCompilerImport.js

@@ -1,113 +0,0 @@
-import * as t from '@babel/types';
-import traverseModule from '@babel/traverse';
-// Handle CommonJS/ESM interop
-const traverse = traverseModule.default || traverseModule;
-/**
- * Given the vite config file ast, checks if the @generaltranslation/compiler package is imported.
- * If it is imported, capture any aliases or namespace.
- *
- * Does not handle:
- * - Nested expressions
- */
-export function checkCompilerImport(ast) {
-    const result = {
-        hasCompilerImport: false,
-        alias: null,
-        namespaces: [],
-    };
-    traverse(ast, {
-        ImportDeclaration(path) {
-            handleImportDeclaration(path, result);
-        },
-        VariableDeclaration(path) {
-            handleVariableDeclaration(path, result);
-        },
-    });
-    return result;
-}
-/* =============================== */
-/* Parsing Functions */
-/* =============================== */
-/**
- * Checks an import declaration for a compiler import
- * @param path - The import declaration path
- * @param result - The result object
- */
-function handleImportDeclaration(path, result) {
-    if (path.node.source.value !== '@generaltranslation/compiler')
-        return;
-    for (const spec of path.node.specifiers) {
-        if (t.isImportSpecifier(spec)) {
-            // Handle named import: import { vite as gtCompiler } from '@generaltranslation/compiler'
-            if (t.isIdentifier(spec.imported) && spec.imported.name === 'vite') {
-                result.hasCompilerImport = true;
-                result.alias = spec.local.name;
-            }
-        }
-        else {
-            // Handle default import: import gtCompiler from '@generaltranslation/compiler'
-            // Handle namespace import: import * as gtCompiler from '@generaltranslation/compiler'
-            result.hasCompilerImport = true;
-            result.namespaces.push(spec.local.name);
-        }
-    }
-}
-/**
- * Handles a variable declaration for a compiler import
- * @param path - The variable declaration path
- * @param result - The result object
- */
-function handleVariableDeclaration(path, result) {
-    path.node.declarations.forEach((dec) => {
-        // Handle destructuring: const { withGTConfig } = require('@generaltranslation/compiler')
-        if (t.isCallExpression(dec.init) &&
-            t.isIdentifier(dec.init.callee, { name: 'require' }) &&
-            t.isStringLiteral(dec.init.arguments[0], {
-                value: '@generaltranslation/compiler',
-            })) {
-            if (t.isIdentifier(dec.id)) {
-                // Handle namespace assignment: const gtCompiler = require('@generaltranslation/compiler')
-                result.hasCompilerImport = true;
-                result.namespaces.push(dec.id.name);
-            }
-            else if (t.isObjectPattern(dec.id)) {
-                // Handle destructuring: const { vite: gtCompiler } = require('@generaltranslation/compiler')
-                let foundVite = false;
-                const restElements = [];
-                for (const prop of dec.id.properties) {
-                    if (t.isObjectProperty(prop) &&
-                        t.isIdentifier(prop.key) &&
-                        t.isIdentifier(prop.value) &&
-                        prop.key.name === 'vite') {
-                        // Handle destructing alias assignment: const { vite: gtCompiler } = require('@generaltranslation/compiler')
-                        result.hasCompilerImport = true;
-                        result.alias = prop.value.name;
-                        foundVite = true;
-                        break;
-                    }
-                    else if (t.isRestElement(prop) && t.isIdentifier(prop.argument)) {
-                        // Track list of rest elements
-                        restElements.push(prop.argument.name);
-                    }
-                }
-                // Handle destructuring rest elements: const { ...some, b, ...others, d } = require('@generaltranslation/compiler')
-                if (!foundVite && restElements.length > 0) {
-                    result.hasCompilerImport = true;
-                    result.namespaces.push(...restElements);
-                }
-            }
-        }
-        else if (t.isMemberExpression(dec.init) &&
-            t.isCallExpression(dec.init.object) &&
-            t.isIdentifier(dec.init.object.callee, { name: 'require' }) &&
-            t.isStringLiteral(dec.init.object.arguments[0], {
-                value: '@generaltranslation/compiler',
-            }) &&
-            t.isIdentifier(dec.init.property, { name: 'vite' }) &&
-            t.isIdentifier(dec.id)) {
-            // Handle member access: const gtCompiler = require('@generaltranslation/compiler').vite
-            result.hasCompilerImport = true;
-            result.alias = dec.id.name;
-        }
-    });
-}

package/dist/react/parse/addVitePlugin/utils/checkPluginInvocation.d.ts

@@ -1,12 +0,0 @@
-import { ParseResult } from '@babel/parser';
-import * as t from '@babel/types';
-/**
- * Checks if the given AST is exporting the gtCompiler plugin
- *
- * Naive check: see if the plugin has been invoked anywhere in the file
- */
-export declare function checkPluginInvocation({ ast, alias, namespaces, }: {
-    ast: ParseResult<t.File>;
-    alias: string | null;
-    namespaces: string[];
-}): boolean;

package/dist/react/parse/addVitePlugin/utils/checkPluginInvocation.js

@@ -1,32 +0,0 @@
-import * as t from '@babel/types';
-import traverseModule from '@babel/traverse';
-// Handle CommonJS/ESM interop
-const traverse = traverseModule.default || traverseModule;
-/**
- * Checks if the given AST is exporting the gtCompiler plugin
- *
- * Naive check: see if the plugin has been invoked anywhere in the file
- */
-export function checkPluginInvocation({ ast, alias, namespaces, }) {
-    let result = false;
-    traverse(ast, {
-        CallExpression(path) {
-            // Handle: gtCompiler()
-            if (!alias)
-                return;
-            if (t.isIdentifier(path.node.callee, { name: alias })) {
-                result = true;
-            }
-        },
-        MemberExpression(path) {
-            // Handle: gtCompiler.vite()
-            if (t.isIdentifier(path.node.object) &&
-                namespaces.includes(path.node.object.name) &&
-                t.isCallExpression(path.parent) &&
-                t.isIdentifier(path.node.property, { name: 'vite' })) {
-                result = true;
-            }
-        },
-    });
-    return result;
-}

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

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

package/dist/react/parse/createDictionaryUpdates.js

@@ -1,187 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'os';
-import { build } from 'esbuild';
-import flattenDictionary from '../utils/flattenDictionary.js';
-import loadJSON from '../../fs/loadJSON.js';
-import { hashSource } from 'generaltranslation/id';
-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, warnInvalidMaxCharsSync, } from '../../console/index.js';
-import { exitSync } from '../../console/logging.js';
-export async function createDictionaryUpdates(dictionaryPath, errors, warnings, esbuildConfig) {
-    let dictionary;
-    // ---- HANDLE JSON STRING DICTIONARY ----- //
-    if (dictionaryPath.endsWith('.json')) {
-        dictionary = flattenDictionary(loadJSON(dictionaryPath) || {});
-    }
-    // ----- HANDLE REACT DICTIONARY ---- //
-    else {
-        const result = await build({
-            ...esbuildConfig,
-            entryPoints: [dictionaryPath],
-            write: false,
-        });
-        const bundledCode = result.outputFiles[0].text;
-        const tempFilePath = path.join(os.tmpdir(), `bundled-dictionary-${randomUUID()}.js`);
-        await fs.promises.writeFile(tempFilePath, bundledCode);
-        // Load the module using dynamic import
-        let dictionaryModule;
-        try {
-            dictionaryModule = await import(tempFilePath);
-        }
-        catch (error) {
-            logger.error(`Failed to load the bundled dictionary code: ${error}`);
-            exitSync(1);
-        }
-        finally {
-            // Clean up the temporary file
-            await fs.promises.unlink(tempFilePath);
-        }
-        const unwrappedDictionary = unwrapDictionaryModule(dictionaryModule);
-        dictionary = flattenDictionary(unwrappedDictionary);
-    }
-    // ----- CREATE PARTIAL UPDATES ----- //
-    const updates = [];
-    for (const id of Object.keys(dictionary)) {
-        const { entry, metadata: props, // context, etc.
-         } = getEntryAndMetadata(dictionary[id]);
-        // Validate ICU
-        const { isValid, error } = isValidIcu(entry);
-        if (!isValid) {
-            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',
-            }),
-        };
-        updates.push({
-            dataFormat: 'ICU',
-            source: entry,
-            metadata,
-        });
-    }
-    return updates;
-}
-function unwrapDictionaryModule(mod) {
-    let current = mod;
-    // Keep unwrapping until we get to the actual dictionary
-    while (current && typeof current === 'object') {
-        const keys = Object.keys(current);
-        // Check if this looks like a module namespace object (has only module-related keys)
-        const isModuleNamespace = keys.every((key) => key === 'default' || key === 'module.exports' || key === '__esModule');
-        // Check if this is a module with named exports (has 'dictionary' export)
-        // Only check for named exports if it's NOT a pure module namespace
-        const hasNamedDictionary = !isModuleNamespace &&
-            'dictionary' in current &&
-            current.dictionary &&
-            typeof current.dictionary === 'object' &&
-            !Array.isArray(current.dictionary);
-        if (hasNamedDictionary) {
-            // If there's a named 'dictionary' export, use that
-            return current.dictionary;
-        }
-        else if (isModuleNamespace) {
-            // Try to get the default export
-            if ('default' in current) {
-                let result = current.default;
-                // If the default export is a function (getter), call it
-                if (typeof result === 'function') {
-                    try {
-                        result = result();
-                    }
-                    catch {
-                        // If calling fails, break the loop
-                        break;
-                    }
-                }
-                // If we have a valid object, check if we should continue unwrapping
-                if (result && typeof result === 'object' && !Array.isArray(result)) {
-                    const resultKeys = Object.keys(result);
-                    // Only continue unwrapping if this looks like a getter-based module layer
-                    // We should NOT continue if this is just a user dictionary with a 'default' property
-                    const hasGetterProperties = resultKeys.some((key) => {
-                        try {
-                            const descriptor = Object.getOwnPropertyDescriptor(result, key);
-                            return descriptor && typeof descriptor.get === 'function';
-                        }
-                        catch {
-                            return false;
-                        }
-                    });
-                    if (hasGetterProperties) {
-                        current = result;
-                        continue;
-                    }
-                    else {
-                        // This is the actual dictionary, return it
-                        return result;
-                    }
-                }
-            }
-            // Try module.exports as fallback
-            if ('module.exports' in current) {
-                let result = current['module.exports'];
-                if (typeof result === 'function') {
-                    try {
-                        result = result();
-                    }
-                    catch {
-                        // If calling fails, break the loop
-                        break;
-                    }
-                }
-                if (result && typeof result === 'object' && !Array.isArray(result)) {
-                    const resultKeys = Object.keys(result);
-                    // Only continue unwrapping if this looks like a getter-based module layer
-                    // We should NOT continue if this is just a user dictionary with a 'default' property
-                    const hasGetterProperties = resultKeys.some((key) => {
-                        try {
-                            const descriptor = Object.getOwnPropertyDescriptor(result, key);
-                            return descriptor && typeof descriptor.get === 'function';
-                        }
-                        catch {
-                            return false;
-                        }
-                    });
-                    if (hasGetterProperties) {
-                        current = result;
-                        continue;
-                    }
-                    else {
-                        // This is the actual dictionary, return it
-                        return result;
-                    }
-                }
-            }
-            // If we can't unwrap further, break
-            break;
-        }
-        else {
-            // This appears to be the actual dictionary object, not a module wrapper
-            break;
-        }
-    }
-    return current || {};
-}

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

@@ -1,13 +0,0 @@
-import { Updates } from '../../types/index.js';
-import type { ParsingConfigOptions } from '../../types/parsing.js';
-import { GTLibrary } from '../../types/libraries.js';
-export declare function createInlineUpdates(pkg: GTLibrary, validate: boolean, filePatterns: string[] | undefined, parsingOptions: ParsingConfigOptions): Promise<{
-    updates: Updates;
-    errors: string[];
-    warnings: string[];
-}>;
-/**
- * Dedupe entries
- */
-declare function dedupeUpdates(updates: Updates): void;
-export { dedupeUpdates as _test_dedupeUpdates };

package/dist/react/parse/createInlineUpdates.js

@@ -1,161 +0,0 @@
-import fs from 'node:fs';
-import { parse } from '@babel/parser';
-import { hashSource, hashString } from 'generaltranslation/id';
-import { parseTranslationComponent } from '../jsx/utils/jsxParsing/parseJsx.js';
-import { parseStrings } from '../jsx/utils/parseStringFunction.js';
-import { logger } from '../../console/logger.js';
-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';
-export async function createInlineUpdates(pkg, validate, filePatterns, parsingOptions) {
-    const updates = [];
-    const errors = [];
-    const warnings = new Set();
-    const pkgs = getUpstreamPackages(pkg);
-    // Use the provided app directory or default to the current directory
-    const files = matchFiles(process.cwd(), filePatterns || DEFAULT_SRC_PATTERNS);
-    for (const file of files) {
-        const code = await fs.promises.readFile(file, 'utf8');
-        let ast;
-        try {
-            ast = parse(code, {
-                sourceType: 'module',
-                plugins: ['jsx', 'typescript'],
-            });
-        }
-        catch (error) {
-            logger.error(`Error parsing file ${file}: ${error}`);
-            continue;
-        }
-        // First pass: collect imports and process translation functions
-        const { importAliases, inlineTranslationPaths, translationComponentPaths } = getPathsAndAliases(ast, pkgs);
-        // Process translation functions asynchronously
-        for (const { localName: name, originalName, path, } of inlineTranslationPaths) {
-            parseStrings(name, originalName, path, {
-                parsingOptions,
-                file,
-                ignoreInlineMetadata: false,
-                ignoreDynamicContent: false,
-                ignoreInvalidIcu: false,
-                ignoreInlineListContent: false,
-            }, { updates, errors, warnings });
-        }
-        // Parse <T> components
-        if (REACT_LIBRARIES.includes(pkg)) {
-            for (const { localName, path } of translationComponentPaths) {
-                parseTranslationComponent({
-                    originalName: localName,
-                    localName,
-                    path,
-                    updates,
-                    config: {
-                        importAliases,
-                        parsingOptions,
-                        pkgs,
-                        file,
-                    },
-                    output: {
-                        errors,
-                        warnings,
-                        unwrappedExpressions: [],
-                    },
-                });
-            }
-        }
-    }
-    // Post processing steps:
-    await calculateHashes(updates);
-    dedupeUpdates(updates);
-    linkStaticUpdates(updates);
-    return { updates, errors, warnings: [...warnings] };
-}
-/**
- * Given a package name, return the upstream packages that it depends on
- * @param pkg - The package name
- * @returns The upstream packages that the package depends on
- */
-function getUpstreamPackages(pkg) {
-    return GT_LIBRARIES_UPSTREAM[pkg];
-}
-/**
- * Calculate hashes
- */
-async function calculateHashes(updates) {
-    // parallel calculation of hashes
-    await Promise.all(updates.map(async (update) => {
-        const hash = hashSource({
-            source: update.source,
-            ...(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;
-    }));
-}
-/**
- * Dedupe entries
- */
-function dedupeUpdates(updates) {
-    const mergedByHash = new Map();
-    const noHashUpdates = [];
-    for (const update of updates) {
-        const hash = update.metadata.hash;
-        if (!hash) {
-            noHashUpdates.push(update);
-            continue;
-        }
-        const existing = mergedByHash.get(hash);
-        if (!existing) {
-            mergedByHash.set(hash, update);
-            continue;
-        }
-        const existingPaths = Array.isArray(existing.metadata.filePaths)
-            ? existing.metadata.filePaths.slice()
-            : [];
-        const newPaths = Array.isArray(update.metadata.filePaths)
-            ? update.metadata.filePaths
-            : [];
-        for (const p of newPaths) {
-            if (!existingPaths.includes(p)) {
-                existingPaths.push(p);
-            }
-        }
-        if (existingPaths.length) {
-            existing.metadata.filePaths = existingPaths;
-        }
-    }
-    const mergedUpdates = [...mergedByHash.values(), ...noHashUpdates];
-    updates.splice(0, updates.length, ...mergedUpdates);
-}
-/**
- * Mark static updates as the related by attaching a shared id to static content
- * Id is calculated as the hash of the static children's combined hashes
- */
-function linkStaticUpdates(updates) {
-    // construct map of temporary static ids to updates
-    const temporaryStaticIdToUpdates = updates.reduce((acc, update) => {
-        if (update.metadata.staticId) {
-            if (!acc[update.metadata.staticId]) {
-                acc[update.metadata.staticId] = [];
-            }
-            acc[update.metadata.staticId].push(update);
-        }
-        return acc;
-    }, {});
-    // Calculate shared static ids
-    Object.values(temporaryStaticIdToUpdates).forEach((staticUpdates) => {
-        const hashes = staticUpdates
-            .map((update) => update.metadata.hash)
-            .sort()
-            .join('-');
-        const sharedStaticId = hashString(hashes);
-        staticUpdates.forEach((update) => {
-            update.metadata.staticId = sharedStaticId;
-        });
-    });
-}
-export { dedupeUpdates as _test_dedupeUpdates };

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

@@ -1,12 +0,0 @@
-import { SupportedFrameworks, WrapOptions } from '../../types/index.js';
-import { Libraries } from '../../types/libraries.js';
-/**
- * Wraps all JSX elements in the src directory with a <T> tag, with unique ids.
- * - Ignores pure strings
- *
- * @param options - The options object
- * @returns An object containing the updates and errors
- */
-export declare function wrapContentReact(options: WrapOptions, pkg: `${typeof Libraries.GT_REACT}`, framework: SupportedFrameworks, errors: string[], warnings: string[]): Promise<{
-    filesUpdated: string[];
-}>;