gt 0.10.0 → 2.7.0

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

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,113 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,187 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,161 @@
+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

@@ -0,0 +1,12 @@
+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[];
+}>;