gt 0.10.0 → 2.7.0

package/dist/setup/frameworkUtils.js

@@ -0,0 +1,30 @@
+import { Libraries } from '../types/libraries.js';
+export function getFrameworkDisplayName(frameworkObject) {
+    if (frameworkObject.name === 'mintlify') {
+        return 'Mintlify';
+    }
+    if (frameworkObject.name === 'next-app') {
+        return 'Next.js App Router';
+    }
+    if (frameworkObject.name === 'next-pages') {
+        return 'Next.js Pages Router';
+    }
+    if (frameworkObject.name === 'vite') {
+        return 'Vite + React';
+    }
+    if (frameworkObject.name === 'gatsby') {
+        return 'Gatsby';
+    }
+    if (frameworkObject.name === 'redwood') {
+        return 'RedwoodJS';
+    }
+    if (frameworkObject.type === 'react') {
+        return 'React';
+    }
+    return 'another framework';
+}
+export function getReactFrameworkLibrary(frameworkObject) {
+    return frameworkObject.name === 'next-app'
+        ? Libraries.GT_NEXT
+        : Libraries.GT_REACT;
+}

package/dist/setup/instructions/base.md

@@ -0,0 +1,29 @@
+# General Translation (GT) Internationalization Rules
+
+This project is using [General Translation](https://generaltranslation.com/docs/overview.md) for internationalization (i18n) and translations. General Translation is a developer-first localization stack, built for the world's best engineering teams to ship apps in every language with ease.
+
+## Configuration
+
+The General Translation configuration file is called `gt.config.json`. It is usually located in the root or src directory of a project.
+
+```json
+{
+  "defaultLocale": "en",
+  "locales": ["es", "fr", "de"],
+  "files": {
+    "json": {
+      "include": ["./**/[locale]/*.json"]
+    }
+  }
+}
+```
+
+The API reference for the config file can be found at <https://generaltranslation.com/docs/cli/reference/config.md>.
+
+## Translation
+
+Run `npx gt translate` to create translation files for your project. You must have an API key to do this.
+
+## Documentation
+
+<https://generaltranslation.com/llms.txt>

package/dist/setup/instructions/gt-next.md

@@ -0,0 +1,107 @@
+# gt-next
+
+This project is using the `gt-next` internationalization library for Next.js App Router.
+
+## gt-next setup
+
+- `GTProvider` must wrap the app in the root layout to provide translation context.
+- The `withGTConfig()` plugin wraps `next.config` in the Next.js config file.
+- (optional) `createNextMiddleware()` is used in `proxy.ts` for automatic locale routing.
+
+## Translating JSX
+
+`gt-next` uses the `<T>` component for translation.
+
+Pass JSX content as the direct children of `<T>` to translate it. Children of `<T>` must be static — no JS expressions or variables directly inside.
+
+```jsx
+import { T } from 'gt-next';
+
+<T>
+  <h1>Welcome to our store</h1>
+  <p>
+    Browse our <a href='/products'>latest products</a> and find something you
+    love.
+  </p>
+</T>;
+```
+
+You can also add a `context` prop to `<T>` to give context to the translator. For example:
+
+```jsx
+import { T } from 'gt-next';
+
+<T context="Cookies as in web cookies">
+  View your <a href="/cookies">Cookies</a>
+</T>;
+```
+
+## Translating simple strings
+
+Use the `gt` function returned by the `useGT()` hook to translate strings directly. Invoke `useGT()` in synchronous components or `await getGT()` in async components only.
+
+```js
+import { useGT } from 'gt-next';
+const gt = useGT();
+gt('Hello, world!'); // returns "Hola, mundo"
+```
+
+```js
+import { getGT } from 'gt-next/server';
+const gt = await getGT(); // use await version in async components only
+gt('Hello, world!');
+```
+
+- Just like with the children of the `<T>` component, all strings passed to `gt()` must be static string literals. No variables or template literals.
+
+## Translating shared or out-of-scope strings
+
+Use `msg()` to register strings for translation, and `useMessages()` to translate them. `const m = useMessages()` should be used equivalently to `const gt = useGT()`.
+
+```js
+import { msg, useMessages } from 'gt-next';
+
+const greeting = msg('Hello, world!');
+
+export default function Greeting() {
+  const m = useMessages();
+  return <p>{m(greeting)}</p>;
+}
+```
+
+- All strings passed to `msg()` must be static string literals. No variables or template literals.
+- Use the equivalent `await getMessages()` for async components.
+- `useMessages()` / `getMessages()` take no arguments.
+
+## Dynamic content inside `<T>`
+
+Use variable components for dynamic values inside `<T>`:
+
+- `<Var>{value}</Var>` — variables (strings, numbers, etc.)
+- `<Num>{value}</Num>` — formatted numbers
+- `<Currency>{value}</Currency>` — formatted currency
+- `<DateTime>{value}</DateTime>` — formatted dates/times
+
+```jsx
+import { T, Var, Num } from 'gt-next';
+
+<T>
+  <Var>{userName}</Var> ordered <Num>{itemCount}</Num> items.
+</T>;
+```
+
+## Utility hooks
+
+### `useLocale()`
+
+`useLocale` returns the user's current language, as a BCP 47 locale tag.
+
+```js
+import { useLocale } from 'gt-next'
+
+const locale = useLocale(); // "en-US"
+```
+
+## Quickstart
+
+See <https://generaltranslation.com/docs/next.md>

package/dist/setup/instructions/gt-react.md

@@ -0,0 +1,98 @@
+# gt-react
+
+This project is using the `gt-react` internationalization library.
+
+## gt-react setup
+
+- `GTProvider` must wrap the app in the root layout to provide translation context.
+
+## Translating JSX
+
+`gt-react` uses the `<T>` component for translation.
+
+Pass JSX content as the direct children of `<T>` to translate it. Children of `<T>` must be static — no JS expressions or variables directly inside.
+
+```jsx
+import { T } from 'gt-react';
+
+<T>
+  <h1>Welcome to our store</h1>
+  <p>
+    Browse our <a href='/products'>latest products</a> and find something you
+    love.
+  </p>
+</T>;
+```
+
+You can also add a `context` prop to `<T>` to give context to the translator. For example:
+
+```jsx
+import { T } from 'gt-react';
+
+<T context="Cookies as in web cookies">
+  View your <a href="/cookies">Cookies</a>
+</T>;
+```
+
+## Translating simple strings
+
+Use the `gt` function returned by the `useGT()` hook to translate strings directly.
+
+```js
+import { useGT } from 'gt-react';
+const gt = useGT();
+gt('Hello, world!'); // returns "Hola, mundo"
+```
+
+- Just like with the children of the `<T>` component, all strings passed to `gt()` must be static string literals. No variables or template literals.
+
+## Translating shared or out-of-scope strings
+
+Use `msg()` to register strings for translation, and `useMessages()` to translate them. `const m = useMessages()` should be used equivalently to `const gt = useGT()`.
+
+```js
+import { msg, useMessages } from 'gt-react';
+
+const greeting = msg('Hello, world!');
+
+export default function Greeting() {
+  const m = useMessages();
+  return <p>{m(greeting)}</p>;
+}
+```
+
+- All strings passed to `msg()` must be static string literals. No variables or template literals.
+- `useMessages()` / `getMessages()` take no arguments.
+
+## Dynamic content inside `<T>`
+
+Use variable components for dynamic values inside `<T>`:
+
+- `<Var>{value}</Var>` — variables (strings, numbers, etc.)
+- `<Num>{value}</Num>` — formatted numbers
+- `<Currency>{value}</Currency>` — formatted currency
+- `<DateTime>{value}</DateTime>` — formatted dates/times
+
+```jsx
+import { T, Var, Num } from 'gt-react';
+
+<T>
+  <Var>{userName}</Var> ordered <Num>{itemCount}</Num> items.
+</T>;
+```
+
+## Utility hooks
+
+### `useLocale()`
+
+`useLocale` returns the user's current language, as a BCP 47 locale tag.
+
+```js
+import { useLocale } from 'gt-react'
+
+const locale = useLocale(); // "en-US"
+```
+
+## Quickstart
+
+See <https://generaltranslation.com/docs/react.md>

package/dist/setup/userInput.d.ts

@@ -0,0 +1,4 @@
+export declare function getDesiredLocales(): Promise<{
+    defaultLocale: string;
+    locales: string[];
+}>;

package/dist/setup/userInput.js

@@ -0,0 +1,32 @@
+import { libraryDefaultLocale } from 'generaltranslation/internal';
+import { promptText } from '../console/logging.js';
+import chalk from 'chalk';
+import { gt } from '../utils/gt.js';
+export async function getDesiredLocales() {
+    // Ask for the default locale
+    const defaultLocale = await promptText({
+        message: 'What is the default locale for your project?',
+        defaultValue: libraryDefaultLocale,
+    });
+    // Ask for the locales
+    const locales = await promptText({
+        message: `Which languages would you like to translate your project into? Enter your response as a list of BCP-47 locale tags. ${chalk.dim('(space-separated list)')}`,
+        defaultValue: 'es fr de ja zh',
+        validate: (input) => {
+            const localeList = input.split(' ');
+            if (localeList.length === 0) {
+                return 'Please enter at least one locale';
+            }
+            if (localeList.some((locale) => !locale.trim())) {
+                return 'Please enter a valid locale (e.g., es fr de)';
+            }
+            for (const locale of localeList) {
+                if (!gt.isValidLocale(locale)) {
+                    return 'Please enter a valid locale (e.g., es fr de)';
+                }
+            }
+            return true;
+        },
+    });
+    return { defaultLocale, locales: locales.split(' ') };
+}

package/dist/setup/wizard.d.ts

@@ -0,0 +1,3 @@
+import { SetupOptions } from '../types/index.js';
+import { ReactFrameworkObject } from '../types/index.js';
+export declare function handleSetupReactCommand(options: SetupOptions, frameworkObject: ReactFrameworkObject, useDefaults?: boolean): Promise<void>;

package/dist/setup/wizard.js

@@ -0,0 +1,147 @@
+import { detectFormatter } from '../hooks/postProcess.js';
+import { promptSelect } from '../console/logging.js';
+import { logger } from '../console/logger.js';
+import chalk from 'chalk';
+import { promptConfirm } from '../console/logging.js';
+import findFilepath from '../fs/findFilepath.js';
+import { formatFiles } from '../hooks/postProcess.js';
+import { handleInitGT } from '../next/parse/handleInitGT.js';
+import { getPackageJson, isPackageInstalled } from '../utils/packageJson.js';
+import { wrapContentNext } from '../next/parse/wrapContent.js';
+import { getPackageManager } from '../utils/packageManager.js';
+import { installPackage } from '../utils/installPackage.js';
+import { createOrUpdateConfig } from '../fs/config/setupConfig.js';
+import { loadConfig } from '../fs/config/loadConfig.js';
+import { addVitePlugin } from '../react/parse/addVitePlugin/index.js';
+import { exitSync } from '../console/logging.js';
+import { getFrameworkDisplayName } from './frameworkUtils.js';
+import { Libraries } from '../types/libraries.js';
+export async function handleSetupReactCommand(options, frameworkObject, useDefaults = false) {
+    const frameworkDisplayName = getFrameworkDisplayName(frameworkObject);
+    // Ask user for confirmation using inquirer
+    if (!useDefaults) {
+        const answer = await promptConfirm({
+            message: chalk.yellow(`This wizard will configure your ${frameworkDisplayName} project for internationalization with GT. If your project is already using a different i18n library, this wizard may cause issues.
+
+Make sure you have committed or stashed any changes. Do you want to continue?`),
+            defaultValue: true,
+            cancelMessage: 'Operation cancelled. You can re-run this wizard with: npx gt setup',
+        });
+        if (!answer) {
+            logger.info('Operation cancelled. You can re-run this wizard with: npx gt setup');
+            exitSync(0);
+        }
+    }
+    const frameworkType = useDefaults && frameworkObject?.name
+        ? frameworkObject.name
+        : await promptSelect({
+            message: 'Which framework are you using?',
+            options: [
+                { value: 'next-app', label: chalk.blue('Next.js App Router') },
+                { value: 'next-pages', label: chalk.green('Next.js Pages Router') },
+                { value: 'vite', label: chalk.cyan('Vite + React') },
+                { value: 'gatsby', label: chalk.magenta('Gatsby') },
+                { value: 'react', label: chalk.yellow('React') },
+                { value: 'redwood', label: chalk.red('RedwoodJS') },
+                { value: 'other', label: chalk.dim('Other') },
+            ],
+            defaultValue: frameworkObject?.name || 'other',
+        });
+    if (frameworkType === 'other') {
+        logger.error(`Sorry, the wizard doesn't currently support other React frameworks.
+Please let us know what you would like to see added at https://github.com/generaltranslation/gt/issues`);
+        exitSync(0);
+    }
+    // ----- Create a starter gt.config.json file -----
+    await createOrUpdateConfig(options.config || 'gt.config.json', {
+        framework: frameworkType,
+    });
+    const packageJson = await getPackageJson();
+    if (!packageJson) {
+        logger.error(chalk.red('No package.json found in the current directory. Please run this command from the root of your project.'));
+        exitSync(1);
+    }
+    // Check if gt-next or gt-react is installed
+    if (frameworkType === 'next-app' &&
+        !isPackageInstalled(Libraries.GT_NEXT, packageJson)) {
+        const packageManager = await getPackageManager();
+        const spinner = logger.createSpinner('timer');
+        spinner.start(`Installing ${Libraries.GT_NEXT} with ${packageManager.name}...`);
+        await installPackage(Libraries.GT_NEXT, packageManager);
+        spinner.stop(chalk.green(`Automatically installed ${Libraries.GT_NEXT}.`));
+    }
+    else if (['next-pages', 'react', 'redwood', 'vite', 'gatsby'].includes(frameworkType) &&
+        !isPackageInstalled(Libraries.GT_REACT, packageJson)) {
+        const packageManager = await getPackageManager();
+        const spinner = logger.createSpinner('timer');
+        spinner.start(`Installing ${Libraries.GT_REACT} with ${packageManager.name}...`);
+        await installPackage(Libraries.GT_REACT, packageManager);
+        spinner.stop(chalk.green(`Automatically installed ${Libraries.GT_REACT}.`));
+    }
+    const errors = [];
+    const warnings = [];
+    let filesUpdated = [];
+    // Read tsconfig.json if it exists
+    const tsconfigPath = findFilepath(['tsconfig.json']);
+    const tsconfigJson = tsconfigPath ? loadConfig(tsconfigPath) : undefined;
+    if (frameworkType === 'next-app') {
+        // Check if they have a next.config.js file
+        const nextConfigPath = findFilepath([
+            './next.config.js',
+            './next.config.ts',
+            './next.config.mjs',
+            './next.config.mts',
+        ]);
+        if (!nextConfigPath) {
+            logger.error('No next.config.[js|ts|mjs|mts] file found.');
+            exitSync(1);
+        }
+        const mergeOptions = {
+            ...options,
+            disableIds: true,
+            disableFormatting: true,
+            skipTs: true,
+            addGTProvider: true,
+        };
+        const spinner = logger.createSpinner();
+        spinner.start('Wrapping JSX content with <T> tags...');
+        // Wrap all JSX elements in the src directory with a <T> tag, with unique ids
+        const { filesUpdated: filesUpdatedNext } = await wrapContentNext(mergeOptions, Libraries.GT_NEXT, errors, warnings);
+        filesUpdated = [...filesUpdated, ...filesUpdatedNext];
+        spinner.stop(chalk.green(`Success! Updated ${chalk.bold.cyan(filesUpdated.length)} files:\n`) + filesUpdated.map((file) => `${chalk.green('-')} ${file}`).join('\n'));
+        // Add the withGTConfig() function to the next.config.js file
+        await handleInitGT(nextConfigPath, errors, warnings, filesUpdated, packageJson, tsconfigJson);
+        logger.step(chalk.green(`Added withGTConfig() to your ${nextConfigPath} file.`));
+    }
+    // Add gt compiler plugin
+    if (frameworkType === 'vite') {
+        await addVitePlugin({
+            errors,
+            warnings,
+            filesUpdated,
+            packageJson,
+            tsconfigJson,
+        });
+    }
+    if (errors.length > 0) {
+        logger.error(chalk.red('Failed to write files:\n') + errors.join('\n'));
+    }
+    if (warnings.length > 0) {
+        logger.warn(chalk.yellow('Warnings encountered:') +
+            '\n' +
+            warnings.map((warning) => `${chalk.yellow('-')} ${warning}`).join('\n'));
+    }
+    const formatter = await detectFormatter();
+    if (!formatter || filesUpdated.length === 0) {
+        return;
+    }
+    const applyFormatting = useDefaults
+        ? true
+        : await promptConfirm({
+            message: `Would you like the wizard to auto-format the modified files? ${chalk.dim(`(${formatter})`)}`,
+            defaultValue: true,
+        });
+    // Format updated files if formatters are available
+    if (applyFormatting)
+        await formatFiles(filesUpdated, formatter);
+}

package/dist/state/recentDownloads.d.ts

@@ -0,0 +1,12 @@
+type DownloadMeta = {
+    branchId: string;
+    fileId: string;
+    versionId: string;
+    locale: string;
+    inputPath?: string;
+};
+export declare function recordDownloaded(filePath: string, meta?: DownloadMeta): void;
+export declare function getDownloaded(): Set<string>;
+export declare function getDownloadedMeta(): Map<string, DownloadMeta>;
+export declare function clearDownloaded(): void;
+export {};

package/dist/state/recentDownloads.js

@@ -0,0 +1,18 @@
+const recent = new Set();
+const recentMeta = new Map();
+export function recordDownloaded(filePath, meta) {
+    recent.add(filePath);
+    if (meta) {
+        recentMeta.set(filePath, meta);
+    }
+}
+export function getDownloaded() {
+    return recent;
+}
+export function getDownloadedMeta() {
+    return recentMeta;
+}
+export function clearDownloaded() {
+    recent.clear();
+    recentMeta.clear();
+}

package/dist/state/translateWarnings.d.ts

@@ -0,0 +1,10 @@
+export type WarningCategory = 'skipped_file' | 'failed_move' | 'failed_translation' | 'failed_download';
+export type TranslateWarning = {
+    category: WarningCategory;
+    fileName: string;
+    reason: string;
+};
+export declare function recordWarning(category: WarningCategory, fileName: string, reason: string): void;
+export declare function getWarnings(): TranslateWarning[];
+export declare function hasWarnings(): boolean;
+export declare function clearWarnings(): void;

package/dist/state/translateWarnings.js

@@ -0,0 +1,13 @@
+const warnings = [];
+export function recordWarning(category, fileName, reason) {
+    warnings.push({ category, fileName, reason });
+}
+export function getWarnings() {
+    return warnings;
+}
+export function hasWarnings() {
+    return warnings.length > 0;
+}
+export function clearWarnings() {
+    warnings.length = 0;
+}

package/dist/translation/parse.d.ts

@@ -0,0 +1,17 @@
+import { Updates, TranslateFlags } from '../types/index.js';
+import type { ParsingConfigOptions } from '../types/parsing.js';
+import { InlineLibrary } from '../types/libraries.js';
+/**
+ * Searches for gt-react or gt-next dictionary files and creates updates for them,
+ * as well as inline updates for <T> tags and useGT()/getGT() calls
+ *
+ * @param options - The options object
+ * @param sourceDictionary - The source dictionary file path
+ * @param pkg - The package name
+ * @returns An object containing the updates and errors
+ */
+export declare function createUpdates(options: TranslateFlags, src: string[] | undefined, sourceDictionary: string | undefined, pkg: InlineLibrary, validate: boolean, parsingOptions: ParsingConfigOptions): Promise<{
+    updates: Updates;
+    errors: string[];
+    warnings: string[];
+}>;

package/dist/translation/parse.js

@@ -0,0 +1,77 @@
+import fs from 'fs';
+import { logger } from '../console/logger.js';
+import loadJSON from '../fs/loadJSON.js';
+import { createDictionaryUpdates } from '../react/parse/createDictionaryUpdates.js';
+import { createInlineUpdates } from '../react/parse/createInlineUpdates.js';
+import createESBuildConfig from '../react/config/createESBuildConfig.js';
+import chalk from 'chalk';
+import { exitSync } from '../console/logging.js';
+/**
+ * Searches for gt-react or gt-next dictionary files and creates updates for them,
+ * as well as inline updates for <T> tags and useGT()/getGT() calls
+ *
+ * @param options - The options object
+ * @param sourceDictionary - The source dictionary file path
+ * @param pkg - The package name
+ * @returns An object containing the updates and errors
+ */
+export async function createUpdates(options, src, sourceDictionary, pkg, validate, parsingOptions) {
+    let updates = [];
+    let errors = [];
+    let warnings = [];
+    // Parse dictionary with esbuildConfig
+    if (sourceDictionary &&
+        fs.existsSync(sourceDictionary) &&
+        fs.statSync(sourceDictionary).isFile()) {
+        if (sourceDictionary.endsWith('.json')) {
+            updates = [
+                ...updates,
+                ...(await createDictionaryUpdates(sourceDictionary, errors, warnings)),
+            ];
+        }
+        else {
+            let esbuildConfig;
+            if (options.jsconfig) {
+                const jsconfig = loadJSON(options.jsconfig);
+                if (!jsconfig) {
+                    logger.error(`Failed to resolve jsconfig.json or tsconfig.json at provided filepath: "${options.jsconfig}"`);
+                    exitSync(1);
+                }
+                esbuildConfig = createESBuildConfig(jsconfig);
+            }
+            else {
+                esbuildConfig = createESBuildConfig({});
+            }
+            updates = [
+                ...updates,
+                ...(await createDictionaryUpdates(sourceDictionary, errors, warnings, esbuildConfig)),
+            ];
+        }
+    }
+    // Scan through project for <T> tags
+    const { updates: newUpdates, errors: newErrors, warnings: newWarnings, } = await createInlineUpdates(pkg, validate, src, parsingOptions);
+    errors = [...errors, ...newErrors];
+    warnings = [...warnings, ...newWarnings];
+    updates = [...updates, ...newUpdates];
+    // Metadata addition and validation
+    const idHashMap = new Map();
+    const duplicateIds = new Set();
+    updates = updates.map((update) => {
+        if (!update.metadata.id)
+            return update;
+        const existingHash = idHashMap.get(update.metadata.id);
+        if (existingHash) {
+            if (existingHash !== update.metadata.hash) {
+                errors.push(`Hashes don't match on two components with the same id: ${chalk.blue(update.metadata.id)}. Check your ${chalk.green('<T>')} tags and dictionary entries and make sure you're not accidentally duplicating IDs.`);
+                duplicateIds.add(update.metadata.id);
+            }
+        }
+        else {
+            idHashMap.set(update.metadata.id, update.metadata.hash);
+        }
+        return update;
+    });
+    // Filter out updates with duplicate IDs
+    updates = updates.filter((update) => !duplicateIds.has(update.metadata.id));
+    return { updates, errors, warnings };
+}

package/dist/translation/stage.d.ts

@@ -0,0 +1,3 @@
+import { Settings, TranslateFlags, Updates } from '../types/index.js';
+import { InlineLibrary } from '../types/libraries.js';
+export declare function aggregateInlineTranslations(options: TranslateFlags, settings: Settings, library: InlineLibrary): Promise<Updates>;

package/dist/translation/stage.js

@@ -0,0 +1,44 @@
+import { logErrorAndExit } from '../console/logging.js';
+import chalk from 'chalk';
+import findFilepath from '../fs/findFilepath.js';
+import { logger } from '../console/logger.js';
+import { createUpdates } from './parse.js';
+export async function aggregateInlineTranslations(options, settings, library) {
+    if (!options.dictionary) {
+        options.dictionary = findFilepath([
+            './dictionary.js',
+            './src/dictionary.js',
+            './dictionary.json',
+            './src/dictionary.json',
+            './dictionary.ts',
+            './src/dictionary.ts',
+        ]);
+    }
+    // ---- CREATING UPDATES ---- //
+    const { updates, errors, warnings } = await createUpdates(options, settings.src, options.dictionary, library, false, settings.parsingOptions);
+    if (warnings.length > 0) {
+        logger.warn(chalk.yellow(`CLI tool encountered ${warnings.length} warnings while scanning for translatable content.\n` +
+            warnings
+                .map((warning) => chalk.yellow('• Warning: ') + chalk.white(warning))
+                .join('\n')));
+    }
+    if (errors.length > 0) {
+        if (options.ignoreErrors) {
+            logger.warn(chalk.yellow(`Warning: CLI tool encountered ${errors.length} syntax errors while scanning for translatable content. These components will not be translated.\n` +
+                errors
+                    .map((error) => chalk.yellow('• ') + chalk.white(error) + '\n')
+                    .join('')));
+        }
+        else {
+            logErrorAndExit(chalk.red(`Error: CLI tool encountered ${errors.length} syntax errors while scanning for translatable content. ${chalk.gray('To ignore these errors, re-run with --ignore-errors')}\n` +
+                errors
+                    .map((error) => chalk.red('• ') + chalk.white(error) + '\n')
+                    .join('')));
+        }
+    }
+    if (updates.length == 0) {
+        logger.error(chalk.red(`No in-line content or dictionaries were found for ${chalk.green(library)}. Are you sure you're running this command in the right directory?`));
+        return updates;
+    }
+    return updates;
+}