gt 2.12.1 → 2.13.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # gtx-cli
 
+## 2.13.0
+
+### Minor Changes
+
+- [#1141](https://github.com/generaltranslation/gt/pull/1141) [`4820643`](https://github.com/generaltranslation/gt/commit/4820643665d5aecacc34c52707c0c81bf4da18ca) Thanks [@ErnestM1234](https://github.com/ErnestM1234)! - feat: auto derive for the t() function
+
 ## 2.12.1
 
 ### Patch Changes

package/dist/config/defaults.d.ts

@@ -0,0 +1,11 @@
+import { BaseParsingFlags, GTParsingFlags } from '../types/parsing.js';
+/**
+ * Default parsing flags for GT files
+ * @property {boolean} autoDerive - Whether to enable auto-derive for the t() function. (true -> 'AUTO', false -> 'DISABLED' {@link ParsingConfig['autoDeriveMethod']})
+ * @property {boolean} includeSourceCodeContext - Include surrounding source code lines as context for translations.
+ */
+export declare const GT_PARSING_FLAGS_DEFAULT: GTParsingFlags;
+/**
+ * Default parsing flags for all files
+ */
+export declare const BASE_PARSING_FLAGS_DEFAULT: BaseParsingFlags;

package/dist/config/defaults.js

@@ -0,0 +1,13 @@
+/**
+ * Default parsing flags for GT files
+ * @property {boolean} autoDerive - Whether to enable auto-derive for the t() function. (true -> 'AUTO', false -> 'DISABLED' {@link ParsingConfig['autoDeriveMethod']})
+ * @property {boolean} includeSourceCodeContext - Include surrounding source code lines as context for translations.
+ */
+export const GT_PARSING_FLAGS_DEFAULT = {
+    autoDerive: true,
+    includeSourceCodeContext: false,
+};
+/**
+ * Default parsing flags for all files
+ */
+export const BASE_PARSING_FLAGS_DEFAULT = {};

package/dist/config/generateSettings.js

@@ -1,4 +1,4 @@
-import { displayProjectId, exitSync, logErrorAndExit, warnApiKeyInConfig, } from '../console/logging.js';
+import { displayProjectId, exitSync, logErrorAndExit, warnApiKeyInConfig, warnDeprecatedField, } from '../console/logging.js';
 import { loadConfig } from '../fs/config/loadConfig.js';
 import { defaultBaseUrl, libraryDefaultLocale, } from 'generaltranslation/internal';
 import fs from 'node:fs';
@@ -12,6 +12,7 @@ import chalk from 'chalk';
 import { resolveConfig } from './resolveConfig.js';
 import { gt } from '../utils/gt.js';
 import { generatePreset } from './optionPresets.js';
+import { GT_PARSING_FLAGS_DEFAULT } from './defaults.js';
 export const DEFAULT_SRC_PATTERNS = [
     'src/**/*.{js,jsx,ts,tsx}',
     'app/**/*.{js,jsx,ts,tsx}',
@@ -85,6 +86,10 @@ export async function generateSettings(flags, cwd = process.cwd()) {
             }
         }
     }
+    // Warn on deprecated includeSourceCodeContext
+    if (gtConfig.files?.gt?.includeSourceCodeContext != null) {
+        warnDeprecatedField('files.gt.includeSourceCodeContext', 'files.gt.parsingFlags.includeSourceCodeContext');
+    }
     // merge options
     const mergedOptions = { ...gtConfig, ...flags };
     // Add defaultLocale if not provided
@@ -141,7 +146,10 @@ export async function generateSettings(flags, cwd = process.cwd()) {
             transformPaths: {},
             publishPaths: new Set(),
             unpublishPaths: new Set(),
-            gtJson: {},
+            parsingFlags: {},
+            gtJson: {
+                parsingFlags: GT_PARSING_FLAGS_DEFAULT,
+            },
         };
     mergedOptions.options = {
         ...(mergedOptions.options || {}),

package/dist/console/index.d.ts

@@ -23,6 +23,7 @@ export declare const warnRecursiveFunctionCallSync: (file: string, functionName:
 export declare const warnDeriveFunctionNotWrappedSync: (file: string, functionName: string, location?: string) => string;
 export declare const warnDeriveNonConstVariableSync: (file: string, varName: string, kind: string, location?: string) => string;
 export declare const warnDeriveFunctionNoResultsSync: (file: string, functionName: string, location?: string) => string;
+export declare const warnAutoDeriveNoResultsSync: (file: string, expression: string, location?: string) => string;
 export declare const warnDeriveUnresolvableValueSync: (file: string, key: string, location?: string) => string;
 export declare const warnDeriveCircularSpreadSync: (file: string, varName: string, location?: string) => string;
 export declare const warnDeriveDestructuringSync: (file: string, varName: string, location?: string) => string;

package/dist/console/index.js

@@ -34,6 +34,7 @@ export const warnRecursiveFunctionCallSync = (file, functionName, location) => w
 export const warnDeriveFunctionNotWrappedSync = (file, functionName, location) => withLocation(file, withDeriveFunctionError(`Could not resolve ${colorizeFunctionName(formatCodeClamp(functionName))}. This call is not wrapped in derive() (formerly declareStatic()). Ensure the function is properly wrapped with derive() and does not have circular import dependencies.`), location);
 export const warnDeriveNonConstVariableSync = (file, varName, kind, location) => withLocation(file, withDeriveFunctionError(`Variable ${colorizeFunctionName(varName)} is declared with '${kind}' but only 'const' declarations can be resolved statically. Change it to 'const'.`), location);
 export const warnDeriveFunctionNoResultsSync = (file, functionName, location) => withLocation(file, withDeriveFunctionError(`Could not resolve ${colorizeFunctionName(formatCodeClamp(functionName))}. derive() (formerly declareStatic()) can only receive function invocations and cannot use undefined values or looped calls to construct its result.`), location);
+export const warnAutoDeriveNoResultsSync = (file, expression, location) => withLocation(file, `Auto-derive could not resolve ${colorizeFunctionName(formatCodeClamp(expression))}. Only function calls with statically determinable return values can be used directly in t(). Consider wrapping with derive() for explicit derivation, or use an interpolation variable instead.`, location);
 export const warnDeriveUnresolvableValueSync = (file, key, location) => withLocation(file, withDeriveFunctionError(`Object property ${colorizeFunctionName(formatCodeClamp(key))} could not be resolved to a static string value. Only string literals, template literals, conditionals, and function calls returning strings are supported.`), location);
 export const warnDeriveCircularSpreadSync = (file, varName, location) => withLocation(file, withDeriveFunctionError(`Circular spread detected involving ${colorizeFunctionName(varName)}. Spread references that form a cycle cannot be resolved statically.`), location);
 export const warnDeriveDestructuringSync = (file, varName, location) => withLocation(file, withDeriveFunctionError(`Variable ${colorizeFunctionName(varName)} uses destructuring syntax, which is not yet supported in derive(). Assign the value to a const variable directly instead.`), location);

package/dist/console/logging.d.ts

@@ -45,6 +45,7 @@ export declare function warnNoId(file: string): void;
 export declare function warnHasUnwrappedExpression(file: string, id: string, unwrappedExpressions: string[]): void;
 export declare function warnTemplateLiteral(file: string, value: string): void;
 export declare function warnTernary(file: string): void;
+export declare function warnDeprecatedField(deprecatedField: string, replacement: string): void;
 /**
  * Helper: Log all collected files
  */

package/dist/console/logging.js

@@ -154,6 +154,10 @@ export function warnTernary(file) {
     logger.warn(`Found ternary expression in ${chalk.cyan(file)}. ` +
         chalk.white('A Branch component may be more appropriate here.'));
 }
+export function warnDeprecatedField(deprecatedField, replacement) {
+    logger.warn(`${chalk.green(deprecatedField)} is deprecated. ` +
+        chalk.white(`Use ${chalk.green(replacement)} instead.`));
+}
 /**
  * Helper: Log all collected files
  */

package/dist/fs/config/parseFilesConfig.d.ts

@@ -1,4 +1,4 @@
-import { FilesOptions, IncludePattern, ResolvedFiles, TransformFiles, TransformOption } from '../../types/index.js';
+import { FilesOptions, IncludePattern, ResolvedFiles, Settings, TransformOption } from '../../types/index.js';
 /**
  * Resolves the files from the files object
  * Replaces [locale] with the actual locale in the files
@@ -25,17 +25,7 @@ export declare function normalizeIncludePatterns(patterns: IncludePattern[]): {
  * @param files - The files object
  * @returns The resolved files
  */
-export declare function resolveFiles(files: FilesOptions, locale: string, locales: string[], cwd: string, compositePatterns?: string[]): {
-    resolvedPaths: ResolvedFiles;
-    placeholderPaths: ResolvedFiles;
-    transformPaths: TransformFiles;
-    publishPaths: Set<string>;
-    unpublishPaths: Set<string>;
-    gtJson: {
-        publish?: boolean;
-        includeSourceCodeContext?: boolean;
-    };
-};
+export declare function resolveFiles(files: FilesOptions, locale: string, locales: string[], cwd: string, compositePatterns?: string[]): Settings['files'];
 export declare function expandGlobPatterns(cwd: string, includePatterns: string[], excludePatterns: string[], locale: string, locales: string[], transformPatterns?: TransformOption | string | TransformOption[], compositePatterns?: string[]): {
     resolvedPaths: string[];
     placeholderPaths: string[];

package/dist/fs/config/parseFilesConfig.js

@@ -4,6 +4,7 @@ import { SUPPORTED_FILE_EXTENSIONS } from '../../formats/files/supportedFiles.js
 import { logger } from '../../console/logger.js';
 import chalk from 'chalk';
 import micromatch from 'micromatch';
+import { BASE_PARSING_FLAGS_DEFAULT, GT_PARSING_FLAGS_DEFAULT, } from '../../config/defaults.js';
 /**
  * Resolves the files from the files object
  * Replaces [locale] with the actual locale in the files
@@ -55,11 +56,12 @@ export function normalizeIncludePatterns(patterns) {
  */
 export function resolveFiles(files, locale, locales, cwd, compositePatterns) {
     // Initialize result object with empty arrays for each file type
-    const result = {};
+    const resolvedPaths = {};
     const placeholderResult = {};
     const transformPaths = {};
     const publishPaths = new Set();
     const unpublishPaths = new Set();
+    const parsingFlags = {};
     // Process GT files
     if (files.gt?.output) {
         placeholderResult.gt = path.resolve(cwd, files.gt.output);
@@ -77,21 +79,32 @@ export function resolveFiles(files, locale, locales, cwd, compositePatterns) {
         if (files[fileType]?.include) {
             const { paths, publishPatterns, unpublishPatterns } = normalizeIncludePatterns(files[fileType].include);
             const filePaths = expandGlobPatterns(cwd, paths, files[fileType]?.exclude || [], locale, locales, transformPaths[fileType] || undefined, compositePatterns);
-            result[fileType] = filePaths.resolvedPaths;
+            resolvedPaths[fileType] = filePaths.resolvedPaths;
             placeholderResult[fileType] = filePaths.placeholderPaths;
             // Classify resolved paths into publish/unpublish sets
             classifyPublishPaths(filePaths.resolvedPaths, publishPatterns, unpublishPatterns, cwd, locale, publishPaths, unpublishPaths);
         }
+        // ==== OTHER ==== //
+        if (files[fileType]?.parsingFlags) {
+            parsingFlags[fileType] = {
+                ...BASE_PARSING_FLAGS_DEFAULT,
+                ...files[fileType].parsingFlags,
+            };
+        }
     }
     return {
-        resolvedPaths: result,
+        resolvedPaths,
         placeholderPaths: placeholderResult,
         transformPaths: transformPaths,
         publishPaths,
         unpublishPaths,
+        parsingFlags,
         gtJson: {
             publish: files.gt?.publish,
-            includeSourceCodeContext: files.gt?.includeSourceCodeContext,
+            parsingFlags: {
+                ...GT_PARSING_FLAGS_DEFAULT,
+                ...(files.gt?.parsingFlags || {}),
+            },
         },
     };
 }

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const PACKAGE_VERSION = "2.12.1";
+export declare const PACKAGE_VERSION = "2.13.0";

package/dist/generated/version.js

@@ -1,2 +1,2 @@
 // This file is auto-generated. Do not edit manually.
-export const PACKAGE_VERSION = '2.12.1';
+export const PACKAGE_VERSION = '2.13.0';

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

@@ -1,5 +1,5 @@
 import * as t from '@babel/types';
-import { INLINE_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK_ASYNC, INLINE_MESSAGE_HOOK, INLINE_MESSAGE_HOOK_ASYNC, STRING_REGISTRATION_FUNCS, T_GLOBAL_REGISTRATION_FUNCTION_MARKER, } from './constants.js';
+import { INLINE_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK_ASYNC, INLINE_MESSAGE_HOOK, INLINE_MESSAGE_HOOK_ASYNC, STRING_REGISTRATION_FUNCS, T_GLOBAL_REGISTRATION_FUNCTION_MARKER, T_REGISTRATION_FUNCTION, } from './constants.js';
 import { warnAsyncUseGT, warnSyncGetGT } from '../../../console/index.js';
 import traverseModule from '@babel/traverse';
 // Handle CommonJS/ESM interop
@@ -80,8 +80,8 @@ export function resolveVariableAliases(scope, variableName, visited = new Set())
 }
 /**
  * Handles how translation callbacks are used within code.
- * This covers both direct translation calls (t('hello')) and prop drilling
- * where the translation callback is passed to other functions (getData(t)).
+ * This covers both direct translation calls (gt('hello')) and prop drilling
+ * where the translation callback is passed to other functions (getData(gt)).
  */
 function handleFunctionCall(tPath, config, state, output) {
     if (tPath.parent.type === 'CallExpression' &&
@@ -278,9 +278,16 @@ function processFunctionInFile(filePath, functionName, argIndex, config, state,
  */
 export function parseStrings(importName, originalName, path, config, output) {
     // Handle global t macro directly — path is already the tag identifier
+    // NOTE: if we decide to add support for a global t() function in addition to the macro,
+    // then we need to add support for skipDeriveInvocation here
     if (originalName === T_GLOBAL_REGISTRATION_FUNCTION_MARKER) {
         if (!config.ignoreGlobalTaggedTemplates) {
-            processTaggedTemplateCall(path, config, output);
+            processTaggedTemplateCall(path, {
+                ...config,
+                autoDeriveMethod: config.autoDeriveMethod === 'AUTO'
+                    ? 'DISABLED'
+                    : config.autoDeriveMethod,
+            }, output);
         }
         return;
     }
@@ -300,11 +307,39 @@ export function parseStrings(importName, originalName, path, config, output) {
                 includeSourceCodeContext: config.includeSourceCodeContext,
                 ignoreTaggedTemplates: false,
                 ignoreGlobalTaggedTemplates: false,
+                // User configurable, otherwise default to AUTO
+                autoDeriveMethod: config.autoDeriveMethod === 'AUTO'
+                    ? 'DISABLED'
+                    : config.autoDeriveMethod,
             };
             // Check if this is a direct call to msg('string') or t('string')
             if (refPath.parent.type === 'CallExpression' &&
                 refPath.parent.callee === refPath.node) {
-                processTranslationCall(refPath, stringRegistrationConfig, output);
+                /**
+                 * SPECIAL CASE: Auto-derive t() function
+                 * The t() function, will treat variable content as if it was marked for derivation
+                 * without explicit calls to derive().
+                 *
+                 * @example
+                 * const derivedValue = 'John';
+                 * const interpolatedValue = "Ernest"
+                 * t(
+                 *   "Hello, " + derivedValue + "! My name is {interpolatedValue}",
+                 *   { interpolatedValue }
+                 * );
+                 * // "Hello, John! My name is {interpolatedValue}"
+                 */
+                if (originalName === T_REGISTRATION_FUNCTION) {
+                    processTranslationCall(refPath, config.autoDeriveMethod === 'AUTO'
+                        ? {
+                            ...stringRegistrationConfig,
+                            autoDeriveMethod: 'ENABLED',
+                        }
+                        : stringRegistrationConfig, output);
+                }
+                else {
+                    processTranslationCall(refPath, stringRegistrationConfig, output);
+                }
             }
             else if (!stringRegistrationConfig.ignoreTaggedTemplates &&
                 refPath.parent.type === 'TaggedTemplateExpression' &&
@@ -348,6 +383,10 @@ export function parseStrings(importName, originalName, path, config, output) {
                 includeSourceCodeContext: config.includeSourceCodeContext,
                 ignoreTaggedTemplates: false,
                 ignoreGlobalTaggedTemplates: false,
+                // User configurable, otherwise default to DISABLED
+                autoDeriveMethod: config.autoDeriveMethod === 'AUTO'
+                    ? 'DISABLED'
+                    : config.autoDeriveMethod,
             };
             const effectiveParent = parentPath?.node.type === 'AwaitExpression'
                 ? parentPath.parentPath

package/dist/react/jsx/utils/stringParsing/derivation/handleDerivation.d.ts

@@ -12,13 +12,15 @@ export type StringTree = (string | StringTree)[];
  * @param parsingOptions - Parsing configuration
  * @param errors - Errors to add to
  * @param runtimeInterpolationState - When provided, non-derive dynamic expressions become {n} placeholders instead of errors. Pass { index: 0 } at the entry point for template macros.
+ * @param skipDeriveInvocation - If true, skip derive invocation check
  * @returns Node | null - The parsed node, or null if invalid
  *
  * @note runtimeInterpolationState
  *  - Only provide at entry for template macros, otherwise omit
  *  - t`Hello {nonDerivableValue}` -> t`Hello {0}`
+ *
  */
-export declare function handleDerivation({ expr, tPath, file, parsingOptions, errors, warnings, runtimeInterpolationState, }: {
+export declare function handleDerivation({ expr, tPath, file, parsingOptions, errors, warnings, runtimeInterpolationState, skipDeriveInvocation, }: {
     expr: t.Expression;
     tPath: NodePath;
     file: string;
@@ -28,4 +30,5 @@ export declare function handleDerivation({ expr, tPath, file, parsingOptions, er
     runtimeInterpolationState?: {
         index: number;
     };
+    skipDeriveInvocation?: boolean;
 }): StringNode | null;

package/dist/react/jsx/utils/stringParsing/derivation/handleDerivation.js

@@ -4,7 +4,7 @@ import { buildImportMap } from '../../buildImportMap.js';
 import { resolveImportPath } from '../../resolveImportPath.js';
 import { parse } from '@babel/parser';
 import fs from 'node:fs';
-import { warnFunctionNotFoundSync, warnDeriveFunctionNoResultsSync, warnDeriveFunctionNotWrappedSync, } from '../../../../../console/index.js';
+import { warnFunctionNotFoundSync, warnDeriveFunctionNoResultsSync, warnDeriveFunctionNotWrappedSync, warnAutoDeriveNoResultsSync, } from '../../../../../console/index.js';
 import traverseModule from '@babel/traverse';
 import generateModule from '@babel/generator';
 import { isDeriveCall } from './isDeriveCall.js';
@@ -32,13 +32,15 @@ const processFunctionCache = new Map();
  * @param parsingOptions - Parsing configuration
  * @param errors - Errors to add to
  * @param runtimeInterpolationState - When provided, non-derive dynamic expressions become {n} placeholders instead of errors. Pass { index: 0 } at the entry point for template macros.
+ * @param skipDeriveInvocation - If true, skip derive invocation check
  * @returns Node | null - The parsed node, or null if invalid
  *
  * @note runtimeInterpolationState
  *  - Only provide at entry for template macros, otherwise omit
  *  - t`Hello {nonDerivableValue}` -> t`Hello {0}`
+ *
  */
-export function handleDerivation({ expr, tPath, file, parsingOptions, errors, warnings, runtimeInterpolationState, }) {
+export function handleDerivation({ expr, tPath, file, parsingOptions, errors, warnings, runtimeInterpolationState, skipDeriveInvocation, }) {
     if (!expr) {
         return null;
     }
@@ -115,6 +117,7 @@ export function handleDerivation({ expr, tPath, file, parsingOptions, errors, wa
                         errors,
                         warnings,
                         runtimeInterpolationState,
+                        skipDeriveInvocation,
                     });
                     if (result === null)
                         return null;
@@ -143,6 +146,7 @@ export function handleDerivation({ expr, tPath, file, parsingOptions, errors, wa
             errors,
             warnings,
             runtimeInterpolationState,
+            skipDeriveInvocation,
         });
         const rightResult = handleDerivation({
             expr: expr.right,
@@ -152,6 +156,7 @@ export function handleDerivation({ expr, tPath, file, parsingOptions, errors, wa
             errors,
             warnings,
             runtimeInterpolationState,
+            skipDeriveInvocation,
         });
         if (leftResult === null || rightResult === null) {
             return null;
@@ -168,6 +173,7 @@ export function handleDerivation({ expr, tPath, file, parsingOptions, errors, wa
             errors,
             warnings,
             runtimeInterpolationState,
+            skipDeriveInvocation,
         });
     }
     // Handle numeric literals by converting them to strings
@@ -204,6 +210,21 @@ export function handleDerivation({ expr, tPath, file, parsingOptions, errors, wa
     if (t.isNullLiteral(expr)) {
         return { type: 'text', text: 'null' };
     }
+    // Non-static expression
+    if (skipDeriveInvocation) {
+        // Skip pass a `derive()` invocation to do derivation
+        const variants = resolveCallStringVariants(expr, tPath, file, parsingOptions, errors, warnings);
+        if (variants) {
+            return {
+                type: 'choice',
+                nodes: variants.map((v) => ({ type: 'text', text: v })),
+            };
+        }
+        // Auto-derive had no resolvable results
+        const code = generate(expr).code;
+        errors.push(warnAutoDeriveNoResultsSync(file, code, `${expr.loc?.start?.line}:${expr.loc?.start?.column}`));
+        return null;
+    }
     // Not a derivable expression
     if (runtimeInterpolationState) {
         return { type: 'text', text: `{${runtimeInterpolationState.index++}}` };

package/dist/react/jsx/utils/stringParsing/derivation/index.js

@@ -31,6 +31,7 @@ export function deriveExpression({ tPath, expr, metadata, config, output, index,
         runtimeInterpolationState: enableRuntimeInterpolation
             ? { index: 0 }
             : undefined,
+        skipDeriveInvocation: config.autoDeriveMethod === 'ENABLED',
     });
     // Nothing returned, push error
     if (!stringNode) {

package/dist/react/jsx/utils/stringParsing/types.d.ts

@@ -35,6 +35,13 @@ export type ParsingConfig = {
      * If true, ignore global tagged template expressions (t`hello` without import)
      */
     ignoreGlobalTaggedTemplates: boolean;
+    /**
+     * Skip requirement for a derive() invocation to trigger derivation
+     * - ENABLED: Always auto-derive
+     * - DISABLED: Never auto-derive
+     * - AUTO: Only auto-derive for the t() function
+     */
+    autoDeriveMethod: 'ENABLED' | 'DISABLED' | 'AUTO';
 };
 /**
  * Mutable state for tracking parsing progress.

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

@@ -1,8 +1,8 @@
 import { Updates } from '../../types/index.js';
-import type { ParsingConfigOptions } from '../../types/parsing.js';
+import type { ParsingConfigOptions, GTParsingFlags } from '../../types/parsing.js';
 import { GTLibrary } from '../../types/libraries.js';
 import { dedupeUpdates } from '../../extraction/postProcess.js';
-export declare function createInlineUpdates(pkg: GTLibrary, validate: boolean, filePatterns: string[] | undefined, parsingOptions: ParsingConfigOptions, includeSourceCodeContext?: boolean): Promise<{
+export declare function createInlineUpdates(pkg: GTLibrary, validate: boolean, filePatterns: string[] | undefined, parsingFlags: GTParsingFlags, parsingOptions: ParsingConfigOptions): Promise<{
     updates: Updates;
     errors: string[];
     warnings: string[];

package/dist/react/parse/createInlineUpdates.js

@@ -8,7 +8,7 @@ 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';
 import { calculateHashes, dedupeUpdates, linkDeriveUpdates, } from '../../extraction/postProcess.js';
-export async function createInlineUpdates(pkg, validate, filePatterns, parsingOptions, includeSourceCodeContext = false) {
+export async function createInlineUpdates(pkg, validate, filePatterns, parsingFlags, parsingOptions) {
     const updates = [];
     const errors = [];
     const warnings = new Set();
@@ -39,9 +39,11 @@ export async function createInlineUpdates(pkg, validate, filePatterns, parsingOp
                 ignoreDynamicContent: false,
                 ignoreInvalidIcu: false,
                 ignoreInlineListContent: false,
-                includeSourceCodeContext,
+                includeSourceCodeContext: parsingFlags.includeSourceCodeContext,
                 ignoreTaggedTemplates: false,
                 ignoreGlobalTaggedTemplates: false,
+                // User configurable, otherwise default to AUTO
+                autoDeriveMethod: parsingFlags.autoDerive ? 'AUTO' : 'DISABLED',
             }, { updates, errors, warnings });
         }
         // Parse <T> components
@@ -57,7 +59,7 @@ export async function createInlineUpdates(pkg, validate, filePatterns, parsingOp
                         parsingOptions,
                         pkgs,
                         file,
-                        includeSourceCodeContext,
+                        includeSourceCodeContext: parsingFlags.includeSourceCodeContext,
                     },
                     output: {
                         errors,

package/dist/translation/parse.d.ts

@@ -1,5 +1,5 @@
 import { Updates, TranslateFlags } from '../types/index.js';
-import type { ParsingConfigOptions } from '../types/parsing.js';
+import type { ParsingConfigOptions, GTParsingFlags } from '../types/parsing.js';
 import { InlineLibrary } from '../types/libraries.js';
 /**
  * Searches for gt-react or gt-next dictionary files and creates updates for them,
@@ -10,7 +10,7 @@ import { InlineLibrary } from '../types/libraries.js';
  * @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, includeSourceCodeContext?: boolean): Promise<{
+export declare function createUpdates(options: TranslateFlags, src: string[] | undefined, sourceDictionary: string | undefined, pkg: InlineLibrary, validate: boolean, parsingFlags: GTParsingFlags, parsingOptions: ParsingConfigOptions): Promise<{
     updates: Updates;
     errors: string[];
     warnings: string[];

package/dist/translation/parse.js

@@ -17,7 +17,7 @@ import { isPythonLibrary } from '../types/libraries.js';
  * @param pkg - The package name
  * @returns An object containing the updates and errors
  */
-export async function createUpdates(options, src, sourceDictionary, pkg, validate, parsingOptions, includeSourceCodeContext = false) {
+export async function createUpdates(options, src, sourceDictionary, pkg, validate, parsingFlags, parsingOptions) {
     let updates = [];
     let errors = [];
     let warnings = [];
@@ -53,7 +53,7 @@ export async function createUpdates(options, src, sourceDictionary, pkg, validat
     // Scan through project for translatable content
     const { updates: newUpdates, errors: newErrors, warnings: newWarnings, } = isPythonLibrary(pkg)
         ? await createPythonInlineUpdates(src)
-        : await createInlineUpdates(pkg, validate, src, parsingOptions, includeSourceCodeContext);
+        : await createInlineUpdates(pkg, validate, src, parsingFlags, parsingOptions);
     errors = [...errors, ...newErrors];
     warnings = [...warnings, ...newWarnings];
     updates = [...updates, ...newUpdates];

package/dist/translation/stage.js

@@ -15,7 +15,7 @@ export async function aggregateInlineTranslations(options, settings, library) {
         ]);
     }
     // ---- CREATING UPDATES ---- //
-    const { updates, errors, warnings } = await createUpdates(options, settings.src, options.dictionary, library, false, settings.parsingOptions, settings.files?.gtJson.includeSourceCodeContext ?? false);
+    const { updates, errors, warnings } = await createUpdates(options, settings.src, options.dictionary, library, false, settings.files.gtJson.parsingFlags, settings.parsingOptions);
     if (warnings.length > 0) {
         logger.warn(chalk.yellow(`CLI tool encountered ${warnings.length} warnings while scanning for translatable content.\n` +
             warnings

package/dist/translation/validate.js

@@ -10,7 +10,7 @@ import { Libraries } from '../types/libraries.js';
  */
 async function runValidation(settings, pkg, files) {
     if (files && files.length > 0) {
-        return createInlineUpdates(pkg, true, files, settings.parsingOptions, settings.files?.gtJson.includeSourceCodeContext ?? false);
+        return createInlineUpdates(pkg, true, files, settings.files.gtJson.parsingFlags, settings.parsingOptions);
     }
     // Full project validation
     // Use local variable to avoid mutating caller's settings object
@@ -23,7 +23,7 @@ async function runValidation(settings, pkg, files) {
             './dictionary.ts',
             './src/dictionary.ts',
         ]);
-    return createUpdates(settings, settings.src, dictionary, pkg, true, settings.parsingOptions, settings.files?.gtJson.includeSourceCodeContext ?? false);
+    return createUpdates(settings, settings.src, dictionary, pkg, true, settings.files.gtJson.parsingFlags, settings.parsingOptions);
 }
 /**
  * Parse file path from error/warning string in withLocation format: "filepath (line:col): message"

package/dist/types/index.d.ts

@@ -1,6 +1,6 @@
 import { CustomMapping } from 'generaltranslation/types';
 import { SUPPORTED_FILE_EXTENSIONS } from '../formats/files/supportedFiles.js';
-import { ParsingConfigOptions } from './parsing.js';
+import { ParsingConfigOptions, GTParsingFlags, BaseParsingFlags, ParseFlagsByFileType } from './parsing.js';
 import { Libraries, InlineLibrary } from './libraries.js';
 export type { Updates } from 'generaltranslation/types';
 export type Options = {
@@ -142,11 +142,17 @@ export type FilesOptions = {
         include: IncludePattern[];
         exclude?: string[];
         transform?: string | TransformOption | TransformOption[];
+        parsingFlags?: BaseParsingFlags;
     };
 } & {
     gt?: {
         output: string;
         publish?: boolean;
+        parsingFlags?: Partial<GTParsingFlags>;
+        /**
+         * @deprecated
+         * use `files.gt.parsingFlags.includeSourceCodeContext` instead
+         */
         includeSourceCodeContext?: boolean;
     };
 };
@@ -166,8 +172,14 @@ export type Settings = {
         transformPaths: TransformFiles;
         publishPaths: Set<string>;
         unpublishPaths: Set<string>;
+        parsingFlags: ParseFlagsByFileType;
         gtJson: {
             publish?: boolean;
+            parsingFlags: GTParsingFlags;
+            /**
+             * @deprecated
+             * use {@link files.gt.GTParsingFlags.parsingFlags.includeSourceCodeContext} instead
+             */
             includeSourceCodeContext?: boolean;
         };
     };

package/dist/types/parsing.d.ts

@@ -1,3 +1,46 @@
+import { SupportedFileExtension } from './index.js';
+/**
+ * For monorepo projects, checking for extra exports fields in resolved internal packages.
+ * For instance, an exported path may be labeled as 'browser' or 'module' or 'default'.
+ * These can resolve to different files in the compiled package. This helps us know
+ * which files to check when we do resolution.
+ *
+ * @property conditionNames - The condition names to check for in the resolved package.
+ *
+ * @example
+ * {
+ *   conditionNames: ['development', 'browser', 'module', 'import', 'require', 'default']
+ * }
+ */
 export type ParsingConfigOptions = {
     conditionNames: string[];
 };
+/**
+ * Base parsing flags for all files.
+ * Currently no supported properties
+ *
+ * Future ideas for flags:
+ * - flag for extraction of file name
+ * - flag for extraction of last modified timestamp
+ * - flag for extraction of git history
+ */
+export type BaseParsingFlags = Record<string, unknown>;
+/**
+ * Flags for parsing content. Not to be confused with ParsingConfig which helps us enable/disable
+ * parsing features depending on the function being parsed. Parsing flags is for users to override
+ * some of these defaults or enable/disable other features.
+ *
+ * @property {boolean} autoDerive - Whether to enable auto-derive for the t() function. (true -> 'AUTO', false -> 'DISABLED' {@link ParsingConfig['autoDeriveMethod']})
+ * @property {boolean} includeSourceCodeContext - Include surrounding source code lines as context for translations.
+ */
+export type GTParsingFlags = BaseParsingFlags & {
+    autoDerive: boolean;
+    includeSourceCodeContext: boolean;
+};
+/**
+ * Flags for parsing content with each filetype having its own flags
+ * This is really a helper type that helps us map across filetypes
+ */
+export type ParseFlagsByFileType = {
+    [K in SupportedFileExtension]?: BaseParsingFlags;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gt",
-  "version": "2.12.1",
+  "version": "2.13.0",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [