gt 0.10.0 → 2.7.0

package/dist/translation/validate.d.ts

@@ -0,0 +1,14 @@
+import { Options, Settings } from '../types/index.js';
+import { InlineLibrary, Libraries } from '../types/libraries.js';
+export type ValidationLevel = 'error' | 'warning';
+export type ValidationMessage = {
+    level: ValidationLevel;
+    message: string;
+};
+export type ValidationResult = Record<string, ValidationMessage[]>;
+/**
+ * Programmatic API for validation - returns structured results instead of logging/exiting.
+ * Equivalent to running `gt validate` but returns data.
+ */
+export declare function getValidateJson(settings: Options & Settings, pkg: `${typeof Libraries.GT_REACT}` | `${typeof Libraries.GT_NEXT}` | `${typeof Libraries.GT_REACT_NATIVE}`, files?: string[]): Promise<ValidationResult>;
+export declare function validateProject(settings: Options & Settings, pkg: InlineLibrary, files?: string[]): Promise<void>;

package/dist/translation/validate.js

@@ -0,0 +1,100 @@
+import { logErrorAndExit, stripAnsi } 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';
+import { createInlineUpdates } from '../react/parse/createInlineUpdates.js';
+import { Libraries } from '../types/libraries.js';
+/**
+ * Shared validation logic - returns raw results from createUpdates/createInlineUpdates
+ */
+async function runValidation(settings, pkg, files) {
+    if (files && files.length > 0) {
+        return createInlineUpdates(pkg, true, files, settings.parsingOptions);
+    }
+    // Full project validation
+    // Use local variable to avoid mutating caller's settings object
+    const dictionary = settings.dictionary ||
+        findFilepath([
+            './dictionary.js',
+            './src/dictionary.js',
+            './dictionary.json',
+            './src/dictionary.json',
+            './dictionary.ts',
+            './src/dictionary.ts',
+        ]);
+    return createUpdates(settings, settings.src, dictionary, pkg, true, settings.parsingOptions);
+}
+/**
+ * Parse file path from error/warning string in withLocation format: "filepath (line:col): message"
+ */
+function parseFileFromMessage(msg) {
+    // First try to match with location format: "filepath (line:col): message"
+    // Using [\s\S] instead of . with /s flag for ES5 compatibility
+    const withLocation = msg.match(/^(.+)\s+\(\d+:\d+\)\s*:\s*([\s\S]+)$/);
+    if (withLocation) {
+        return { file: withLocation[1].trim(), message: withLocation[2].trim() };
+    }
+    // Fallback: find the last ": " pattern (handles Windows paths like C:\...)
+    const lastColonSpace = msg.lastIndexOf(': ');
+    if (lastColonSpace > 0) {
+        return {
+            file: msg.substring(0, lastColonSpace).trim(),
+            message: msg.substring(lastColonSpace + 2).trim(),
+        };
+    }
+    // No file found - use empty string as key for "global" messages
+    return { file: '', message: msg };
+}
+/**
+ * Programmatic API for validation - returns structured results instead of logging/exiting.
+ * Equivalent to running `gt validate` but returns data.
+ */
+export async function getValidateJson(settings, 
+// TODO: fix compatability more generally so do not have to do this
+pkg, files) {
+    const validatedPkg = pkg === Libraries.GT_NEXT
+        ? Libraries.GT_NEXT
+        : pkg === Libraries.GT_REACT_NATIVE
+            ? Libraries.GT_REACT_NATIVE
+            : Libraries.GT_REACT;
+    const { errors, warnings } = await runValidation(settings, validatedPkg, files);
+    const result = {};
+    const addMessage = (file, level, message) => {
+        if (!result[file]) {
+            result[file] = [];
+        }
+        result[file].push({ level, message });
+    };
+    for (const error of errors) {
+        const { file, message } = parseFileFromMessage(stripAnsi(error));
+        addMessage(file, 'error', message);
+    }
+    for (const warning of warnings) {
+        const { file, message } = parseFileFromMessage(stripAnsi(warning));
+        addMessage(file, 'warning', message);
+    }
+    return result;
+}
+export async function validateProject(settings, pkg, files) {
+    const { updates, errors, warnings } = await runValidation(settings, pkg, files);
+    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('• ') + chalk.white(warning))
+                .join('\n'));
+    }
+    if (errors.length > 0) {
+        logErrorAndExit(chalk.red(`Error: CLI tool encountered ${errors.length} syntax errors while scanning for translatable content.\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(pkg)}. Are you sure you're running this command in the right directory?`));
+    }
+    else {
+        logger.success(chalk.green(`Success! Found ${updates.length} translatable entries for ${chalk.green(pkg)}.`));
+    }
+}

package/dist/types/branch.d.ts

@@ -0,0 +1,14 @@
+export type BranchData = {
+    currentBranch: {
+        id: string;
+        name: string;
+    };
+    incomingBranch: {
+        id: string;
+        name: string;
+    } | null;
+    checkedOutBranch: {
+        id: string;
+        name: string;
+    } | null;
+};

package/dist/types/branch.js

@@ -0,0 +1 @@
+export {};

package/dist/types/data/json.d.ts

@@ -0,0 +1,6 @@
+type JSONValue = string | number | boolean | null | JSONObject | JSONArray;
+export type JSONObject = {
+    [key: string]: JSONValue;
+};
+export type JSONArray = JSONValue[];
+export {};

package/dist/types/data/json.js

@@ -0,0 +1 @@
+export {};

package/dist/types/data.d.ts

@@ -0,0 +1,37 @@
+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;
+};
+export type DictionaryEntry = Entry | [Entry] | [Entry, DictionaryMetadata];
+export type Dictionary = {
+    [key: string]: Dictionary | DictionaryEntry;
+};
+export type FlattenedDictionary = {
+    [key: string]: DictionaryEntry;
+};
+export type JSONDictionary = {
+    [key: string]: string | JSONDictionary;
+};
+export type FlattenedJSONDictionary = {
+    [key: string]: string;
+};
+export type { FileFormat, DataFormat, FileToUpload, } from 'generaltranslation/types';
+export type JsxChildren = string | string[] | any;
+export type Translations = {
+    [key: string]: JsxChildren;
+};
+export type TranslationsMetadata = {
+    [key: string]: {
+        id?: string;
+        hash?: string;
+    };
+};

package/dist/types/data.js

@@ -0,0 +1 @@
+export {};

package/dist/types/files.d.ts

@@ -0,0 +1,8 @@
+export type FileMapping = Record<string, Record<string, string>>;
+export type FileProperties = {
+    versionId: string;
+    fileName: string;
+    fileId: string;
+    locale: string;
+    branchId: string;
+};

package/dist/types/files.js

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,243 @@
+import { CustomMapping } from 'generaltranslation/types';
+import { SUPPORTED_FILE_EXTENSIONS } from '../formats/files/supportedFiles.js';
+import { ParsingConfigOptions } from './parsing.js';
+import { Libraries, InlineLibrary } from './libraries.js';
+export type { Updates } from 'generaltranslation/types';
+export type Options = {
+    config: string;
+    apiKey?: string;
+    projectId?: string;
+    versionId?: string;
+    jsconfig?: string;
+    dictionary?: string;
+    src?: string[];
+    defaultLocale?: string;
+    locales?: string[];
+    baseUrl: string;
+    inline?: boolean;
+    ignoreErrors: boolean;
+    suppressWarnings: boolean;
+    dryRun: boolean;
+    timeout: number;
+    force?: boolean;
+    stageTranslations?: boolean;
+    experimentalLocalizeStaticUrls?: boolean;
+    experimentalHideDefaultLocale?: boolean;
+    experimentalFlattenJsonFiles?: boolean;
+    experimentalLocalizeStaticImports?: boolean;
+    experimentalLocalizeRelativeAssets?: boolean;
+    experimentalAddHeaderAnchorIds?: 'mintlify' | 'default';
+    docsImportRewrites?: Array<{
+        match: string;
+        replace: string;
+    }>;
+};
+export type OpenApiConfig = {
+    files: string[];
+    translateFields?: string[];
+};
+export type MintlifyOptions = {
+    openapi?: OpenApiConfig;
+    inferTitleFromFilename?: boolean;
+};
+export type SharedFlags = {
+    config?: string;
+    apiKey?: string;
+    projectId?: string;
+};
+export type TranslateFlags = SharedFlags & {
+    versionId?: string;
+    jsconfig?: string;
+    dictionary?: string;
+    defaultLocale?: string;
+    locales?: string[];
+    ignoreErrors?: boolean;
+    src?: string[];
+    timeout: number;
+    dryRun: boolean;
+    saveLocal?: boolean;
+    stageTranslations?: boolean;
+    setupProject?: boolean;
+    publish?: boolean;
+    force?: boolean;
+    forceDownload?: boolean;
+    experimentalLocalizeStaticUrls?: boolean;
+    experimentalHideDefaultLocale?: boolean;
+    experimentalFlattenJsonFiles?: boolean;
+    experimentalLocalizeStaticImports?: boolean;
+    experimentalLocalizeRelativeAssets?: boolean;
+    experimentalAddHeaderAnchorIds?: 'mintlify' | 'default';
+    excludeStaticUrls?: string[];
+    excludeStaticImports?: string[];
+    docsImportRewrites?: Array<{
+        match: string;
+        replace: string;
+    }>;
+};
+export type WrapOptions = {
+    src?: string[];
+    config: string;
+    skipTs: boolean;
+    disableIds: boolean;
+    disableFormatting: boolean;
+    addGTProvider: boolean;
+};
+export type SetupOptions = {
+    src?: string[];
+    config: string;
+};
+export type GenerateSourceOptions = {
+    src?: string[];
+    config: string;
+    defaultLocale: string;
+    dictionary?: string;
+    jsconfig?: string;
+    inline?: boolean;
+    ignoreErrors: boolean;
+    suppressWarnings: boolean;
+};
+export type Framework = typeof Libraries.GT_NEXT | typeof Libraries.GT_REACT | typeof Libraries.GT_REACT_NATIVE;
+export type FrameworkObject = {
+    name: 'mintlify';
+    type?: undefined;
+} | {
+    name: 'next-app' | 'next-pages' | 'vite' | 'gatsby' | 'redwood' | 'react';
+    type: 'react';
+};
+export type ReactFrameworkObject = Extract<FrameworkObject, {
+    type: 'react';
+}>;
+export type FrameworkType = FrameworkObject['type'];
+export type SupportedFrameworks = FrameworkObject['name'];
+export type SupportedReactFrameworks = Extract<FrameworkObject, {
+    type: 'react';
+}>['name'];
+export type SupportedLibraries = InlineLibrary | 'next-intl' | 'react-i18next' | 'next-i18next' | 'i18next' | 'i18next-icu' | 'base';
+export interface ContentScanner {
+    scanForContent(options: WrapOptions, framework: Framework): Promise<{
+        errors: string[];
+        filesUpdated: string[];
+        warnings: string[];
+    }>;
+}
+export type SupportedFileExtension = (typeof SUPPORTED_FILE_EXTENSIONS)[number];
+export type ResolvedFiles = {
+    [K in SupportedFileExtension]?: string[];
+} & {
+    gt?: string;
+};
+export type TransformOption = {
+    match?: string;
+    replace: string;
+};
+export type TransformFiles = {
+    [K in SupportedFileExtension]?: TransformOption | string | TransformOption[];
+};
+export type FilesOptions = {
+    [K in SupportedFileExtension]?: {
+        include: string[];
+        exclude?: string[];
+        transform?: string | TransformOption | TransformOption[];
+    };
+} & {
+    gt?: {
+        output: string;
+    };
+};
+export type Settings = {
+    config: string;
+    configDirectory: string;
+    baseUrl: string;
+    dashboardUrl: string;
+    apiKey?: string;
+    projectId?: string;
+    defaultLocale: string;
+    locales: string[];
+    customMapping?: CustomMapping;
+    files: {
+        resolvedPaths: ResolvedFiles;
+        placeholderPaths: ResolvedFiles;
+        transformPaths: TransformFiles;
+    };
+    stageTranslations: boolean;
+    publish: boolean;
+    _versionId?: string;
+    version?: string;
+    description?: string;
+    src: string[];
+    framework?: SupportedFrameworks;
+    options?: AdditionalOptions;
+    modelProvider?: string;
+    parsingOptions: ParsingConfigOptions;
+    branchOptions: BranchOptions;
+    sharedStaticAssets?: SharedStaticAssetsConfig;
+};
+export type BranchOptions = {
+    currentBranch?: string;
+    autoDetectBranches?: boolean;
+    remoteName: string;
+    enabled: boolean;
+};
+export type AdditionalOptions = {
+    jsonSchema?: {
+        [fileGlob: string]: JsonSchema;
+    };
+    yamlSchema?: {
+        [fileGlob: string]: YamlSchema;
+    };
+    skipFileValidation?: {
+        json?: boolean;
+        yaml?: boolean;
+        mdx?: boolean;
+    };
+    mintlify?: MintlifyOptions;
+    docsUrlPattern?: string;
+    docsImportPattern?: string;
+    excludeStaticUrls?: string[];
+    excludeStaticImports?: string[];
+    docsHideDefaultLocaleImport?: boolean;
+    copyFiles?: string[];
+    experimentalClearLocaleDirs?: boolean;
+    clearLocaleDirsExclude?: string[];
+    experimentalLocalizeStaticImports?: boolean;
+    experimentalLocalizeStaticUrls?: boolean;
+    experimentalLocalizeRelativeAssets?: boolean;
+    experimentalAddHeaderAnchorIds?: 'mintlify' | 'default';
+    experimentalHideDefaultLocale?: boolean;
+    experimentalFlattenJsonFiles?: boolean;
+    baseDomain?: string;
+    docsImportRewrites?: Array<{
+        match: string;
+        replace: string;
+    }>;
+    experimentalCanonicalLocaleKeys?: boolean;
+};
+export type SharedStaticAssetsConfig = {
+    include: string | string[];
+    outDir?: string;
+    publicPath?: string;
+    mirrorToLocales?: boolean;
+};
+export type JsonSchema = {
+    preset?: 'mintlify' | 'openapi';
+    include?: string[];
+    composite?: {
+        [sourceObjectPath: string]: SourceObjectOptions;
+    };
+};
+export type YamlSchema = {
+    preset?: 'mintlify' | 'openapi';
+    include?: string[];
+    transform?: TransformOptions;
+};
+export type SourceObjectOptions = {
+    type: 'array' | 'object';
+    include: string[];
+    key?: string;
+    localeProperty?: string;
+    transform?: TransformOptions;
+    experimentalSort?: 'locales' | 'localesAlphabetical';
+};
+export type TransformOptions = {
+    [transformPath: string]: TransformOption;
+};

package/dist/types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/types/libraries.d.ts

@@ -0,0 +1,31 @@
+/**
+ * A list of all the libraries names supported by the CLI
+ */
+export declare enum Libraries {
+    GT_REACT = "gt-react",
+    GT_NEXT = "gt-next",
+    GT_REACT_NATIVE = "gt-react-native",
+    GT_NODE = "gt-node",
+    GT_I18N = "gt-i18n",
+    GT_REACT_CORE = "@generaltranslation/react-core"
+}
+/**
+ * A list of all the libraries that support the CLI
+ */
+export declare const GT_LIBRARIES: readonly [Libraries.GT_REACT, Libraries.GT_NEXT, Libraries.GT_REACT_NATIVE, Libraries.GT_NODE, Libraries.GT_I18N, Libraries.GT_REACT_CORE];
+export type GTLibrary = (typeof GT_LIBRARIES)[number];
+/**
+ * Libraries that support inline translation
+ */
+export declare const INLINE_LIBRARIES: readonly [Libraries.GT_REACT, Libraries.GT_NEXT, Libraries.GT_NODE, Libraries.GT_REACT_NATIVE, Libraries.GT_REACT_CORE, Libraries.GT_I18N];
+export type InlineLibrary = (typeof INLINE_LIBRARIES)[number];
+export declare function isInlineLibrary(lib: string): lib is InlineLibrary;
+/**
+ * Libraries that support react primitives
+ */
+export declare const REACT_LIBRARIES: readonly [Libraries.GT_NEXT, Libraries.GT_REACT, Libraries.GT_REACT_NATIVE, Libraries.GT_REACT_CORE];
+export type ReactLibrary = (typeof REACT_LIBRARIES)[number];
+/**
+ * A mapping of each library to their upstream dependencies for filtering imports
+ */
+export declare const GT_LIBRARIES_UPSTREAM: Record<GTLibrary, GTLibrary[]>;

package/dist/types/libraries.js

@@ -0,0 +1,72 @@
+/**
+ * A list of all the libraries names supported by the CLI
+ */
+export var Libraries;
+(function (Libraries) {
+    Libraries["GT_REACT"] = "gt-react";
+    Libraries["GT_NEXT"] = "gt-next";
+    Libraries["GT_REACT_NATIVE"] = "gt-react-native";
+    Libraries["GT_NODE"] = "gt-node";
+    Libraries["GT_I18N"] = "gt-i18n";
+    Libraries["GT_REACT_CORE"] = "@generaltranslation/react-core";
+})(Libraries || (Libraries = {}));
+/**
+ * A list of all the libraries that support the CLI
+ */
+export const GT_LIBRARIES = [
+    Libraries.GT_REACT,
+    Libraries.GT_NEXT,
+    Libraries.GT_REACT_NATIVE,
+    Libraries.GT_NODE,
+    Libraries.GT_I18N,
+    Libraries.GT_REACT_CORE,
+];
+/**
+ * Libraries that support inline translation
+ */
+export const INLINE_LIBRARIES = [
+    Libraries.GT_REACT,
+    Libraries.GT_NEXT,
+    Libraries.GT_NODE,
+    Libraries.GT_REACT_NATIVE,
+    Libraries.GT_REACT_CORE,
+    Libraries.GT_I18N,
+];
+export function isInlineLibrary(lib) {
+    return INLINE_LIBRARIES.includes(lib);
+}
+/**
+ * Libraries that support react primitives
+ */
+export const REACT_LIBRARIES = [
+    Libraries.GT_NEXT,
+    Libraries.GT_REACT,
+    Libraries.GT_REACT_NATIVE,
+    Libraries.GT_REACT_CORE,
+];
+/**
+ * A mapping of each library to their upstream dependencies for filtering imports
+ */
+export const GT_LIBRARIES_UPSTREAM = {
+    [Libraries.GT_NEXT]: [
+        Libraries.GT_I18N,
+        Libraries.GT_REACT_CORE,
+        Libraries.GT_REACT,
+        Libraries.GT_NEXT,
+    ],
+    [Libraries.GT_REACT]: [
+        Libraries.GT_I18N,
+        Libraries.GT_REACT_CORE,
+        Libraries.GT_REACT,
+        Libraries.GT_REACT_NATIVE, // allow for cross-library compatibility (gt-react/gt-react-native only)
+    ],
+    [Libraries.GT_REACT_NATIVE]: [
+        Libraries.GT_I18N,
+        Libraries.GT_REACT_CORE,
+        Libraries.GT_REACT_NATIVE,
+        Libraries.GT_REACT, // allow for cross-library compatibility (gt-react/gt-react-native only)
+    ],
+    [Libraries.GT_NODE]: [Libraries.GT_I18N, Libraries.GT_NODE],
+    [Libraries.GT_REACT_CORE]: [Libraries.GT_I18N, Libraries.GT_REACT_CORE],
+    [Libraries.GT_I18N]: [Libraries.GT_I18N],
+};

package/dist/types/parsing.d.ts

@@ -0,0 +1,3 @@
+export type ParsingConfigOptions = {
+    conditionNames: string[];
+};

package/dist/types/parsing.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/addExplicitAnchorIds.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Represents a heading with its position and metadata
+ */
+export interface HeadingInfo {
+    text: string;
+    level: number;
+    slug: string;
+    position: number;
+}
+/**
+ * Extracts heading information from content (read-only, no modifications)
+ */
+export declare function extractHeadingInfo(mdxContent: string): HeadingInfo[];
+/**
+ * Applies anchor IDs to translated content based on source heading mapping
+ */
+export declare function addExplicitAnchorIds(translatedContent: string, sourceHeadingMap: HeadingInfo[], settings?: any, sourcePath?: string, translatedPath?: string, fileTypeHint?: 'md' | 'mdx'): {
+    content: string;
+    hasChanges: boolean;
+    addedIds: Array<{
+        heading: string;
+        id: string;
+    }>;
+};