i18next-cli 0.9.0

package/tsconfig.json

@@ -0,0 +1,71 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig.json to read more about this file */
+
+    /* Basic Options */
+    // "incremental": true,                   /* Enable incremental compilation */
+    "target": "ES2022",                       /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */
+    "module": "ES2022",                       /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */
+    // "lib": [],                             /* Specify library files to be included in the compilation. */
+    // "allowJs": true,                       /* Allow javascript files to be compiled. */
+    // "checkJs": true,                       /* Report errors in .js files. */
+    // "jsx": "preserve",                     /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */
+    // "declaration": true,                   /* Generates corresponding '.d.ts' file. */
+    // "declarationMap": true,                /* Generates a sourcemap for each corresponding '.d.ts' file. */
+    // "sourceMap": true,                     /* Generates corresponding '.map' file. */
+    // "outFile": "./",                       /* Concatenate and emit output to single file. */
+    // "outDir": "./",                        /* Redirect output structure to the directory. */
+    // "rootDir": "./",                       /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
+    // "composite": true,                     /* Enable project compilation */
+    // "tsBuildInfoFile": "./",               /* Specify file to store incremental compilation information */
+    // "removeComments": true,                /* Do not emit comments to output. */
+    // "noEmit": true,                        /* Do not emit outputs. */
+    // "importHelpers": true,                 /* Import emit helpers from 'tslib'. */
+    // "downlevelIteration": true,            /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
+    // "isolatedModules": true,               /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
+
+    /* Strict Type-Checking Options */
+    "strict": true,                           /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,              /* Enable strict null checks. */
+    // "strictFunctionTypes": true,           /* Enable strict checking of function types. */
+    // "strictBindCallApply": true,           /* Enable strict 'bind', 'call', and 'apply' methods on functions. */
+    // "strictPropertyInitialization": true,  /* Enable strict checking of property initialization in classes. */
+    // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
+    // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
+
+    /* Additional Checks */
+    // "noUnusedLocals": true,                /* Report errors on unused locals. */
+    // "noUnusedParameters": true,            /* Report errors on unused parameters. */
+    // "noImplicitReturns": true,             /* Report error when not all code paths in function return a value. */
+    // "noFallthroughCasesInSwitch": true,    /* Report errors for fallthrough cases in switch statement. */
+
+    /* Module Resolution Options */
+    "moduleResolution": "node",               /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
+    // "baseUrl": "./",                       /* Base directory to resolve non-absolute module names. */
+    // "paths": {},                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
+    // "rootDirs": [],                        /* List of root folders whose combined content represents the structure of the project at runtime. */
+    // "typeRoots": [],                       /* List of folders to include type definitions from. */
+    // "types": [],                           /* Type declaration files to be included in compilation. */
+    // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
+    "esModuleInterop": true,                  /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
+    // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
+    // "allowUmdGlobalAccess": true,          /* Allow accessing UMD globals from modules. */
+
+    /* Source Map Options */
+    // "sourceRoot": "",                      /* Specify the location where debugger should locate TypeScript files instead of source locations. */
+    // "mapRoot": "",                         /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,               /* Emit a single file with source maps instead of having a separate file. */
+    // "inlineSources": true,                 /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
+
+    /* Experimental Options */
+    // "experimentalDecorators": true,        /* Enables experimental support for ES7 decorators. */
+    // "emitDecoratorMetadata": true,         /* Enables experimental support for emitting type metadata for decorators. */
+
+    /* Advanced Options */
+    "skipLibCheck": true,                     /* Skip type checking of declaration files. */
+    "forceConsistentCasingInFileNames": true  /* Disallow inconsistently-cased references to the same file. */
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "test/**/*.ts"]
+}

package/types/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/types/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/types/config.d.ts

@@ -0,0 +1,50 @@
+import type { I18nextToolkitConfig } from './types';
+/**
+ * A helper function for defining the i18next-cli config with type-safety.
+ *
+ * @param config - The configuration object to define
+ * @returns The same configuration object with type safety
+ *
+ * @example
+ * ```typescript
+ * export default defineConfig({
+ *   locales: ['en', 'de'],
+ *   extract: {
+ *     input: 'src',
+ *     output: 'locales/{{language}}/{{namespace}}.json'
+ *   }
+ * })
+ * ```
+ */
+export declare function defineConfig(config: I18nextToolkitConfig): I18nextToolkitConfig;
+/**
+ * Loads and validates the i18next toolkit configuration from the project root.
+ *
+ * This function:
+ * 1. Searches for a config file using findConfigFile()
+ * 2. Dynamically imports the config file using ESM import()
+ * 3. Validates the configuration structure
+ * 4. Sets default values for sync options
+ * 5. Adds cache busting for watch mode
+ *
+ * @returns Promise that resolves to the loaded configuration object, or null if loading failed
+ *
+ * @example
+ * ```typescript
+ * const config = await loadConfig()
+ * if (!config) {
+ *   console.error('Failed to load configuration')
+ *   process.exit(1)
+ * }
+ * ```
+ */
+export declare function loadConfig(): Promise<I18nextToolkitConfig | null>;
+/**
+ * NEW: Ensures a configuration exists, prompting the user to create one if necessary.
+ * This function is a wrapper around loadConfig that provides an interactive fallback.
+ *
+ * @returns A promise that resolves to a valid configuration object.
+ * @throws Exits the process if the user declines to create a config or if loading fails after creation.
+ */
+export declare function ensureConfig(): Promise<I18nextToolkitConfig>;
+//# sourceMappingURL=config.d.ts.map

package/types/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAanD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,YAAY,CAAE,MAAM,EAAE,oBAAoB,GAAG,oBAAoB,CAEhF;AAqBD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,UAAU,IAAK,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC,CAsCxE;AAED;;;;;;GAMG;AACH,wBAAsB,YAAY,IAAK,OAAO,CAAC,oBAAoB,CAAC,CA8BnE"}

package/types/extractor/core/extractor.d.ts

@@ -0,0 +1,66 @@
+import type { Logger, ExtractedKey, I18nextToolkitConfig } from '../../types';
+/**
+ * Main extractor function that runs the complete key extraction and file generation process.
+ *
+ * This is the primary entry point that:
+ * 1. Validates configuration
+ * 2. Sets up default sync options
+ * 3. Finds all translation keys across source files
+ * 4. Generates/updates translation files for all locales
+ * 5. Provides progress feedback via spinner
+ * 6. Returns whether any files were updated
+ *
+ * @param config - The i18next toolkit configuration object
+ * @param logger - Logger instance for output (defaults to ConsoleLogger)
+ * @returns Promise resolving to boolean indicating if any files were updated
+ *
+ * @throws {ExtractorError} When configuration validation fails or extraction process encounters errors
+ *
+ * @example
+ * ```typescript
+ * const config = await loadConfig()
+ * const updated = await runExtractor(config)
+ * if (updated) {
+ *   console.log('Translation files were updated')
+ * }
+ * ```
+ */
+export declare function runExtractor(config: I18nextToolkitConfig, logger?: Logger): Promise<boolean>;
+/**
+ * Processes an individual source file for translation key extraction.
+ *
+ * This function:
+ * 1. Reads the source file
+ * 2. Runs plugin onLoad hooks for code transformation
+ * 3. Parses the code into an Abstract Syntax Tree (AST) using SWC
+ * 4. Extracts keys from comments using regex patterns
+ * 5. Traverses the AST using visitors to find translation calls
+ * 6. Runs plugin onVisitNode hooks for custom extraction logic
+ *
+ * @param file - Path to the source file to process
+ * @param config - The i18next toolkit configuration object
+ * @param logger - Logger instance for output
+ * @param allKeys - Map to accumulate found translation keys
+ *
+ * @throws {ExtractorError} When file processing fails
+ *
+ * @internal
+ */
+export declare function processFile(file: string, config: I18nextToolkitConfig, logger: Logger, allKeys: Map<string, ExtractedKey>): Promise<void>;
+/**
+ * Simplified extraction function that returns translation results without file writing.
+ * Used primarily for testing and programmatic access.
+ *
+ * @param config - The i18next toolkit configuration object
+ * @returns Promise resolving to array of translation results
+ *
+ * @example
+ * ```typescript
+ * const results = await extract(config)
+ * for (const result of results) {
+ *   console.log(`${result.path}: ${result.updated ? 'Updated' : 'No changes'}`)
+ * }
+ * ```
+ */
+export declare function extract(config: I18nextToolkitConfig): Promise<import("../../types").TranslationResult[]>;
+//# sourceMappingURL=extractor.d.ts.map

package/types/extractor/core/extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractor.d.ts","sourceRoot":"","sources":["../../../src/extractor/core/extractor.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,EAAE,YAAY,EAAiB,oBAAoB,EAAE,MAAM,aAAa,CAAA;AAS5F;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,YAAY,CAChC,MAAM,EAAE,oBAAoB,EAC5B,MAAM,GAAE,MAA4B,GACnC,OAAO,CAAC,OAAO,CAAC,CA+BlB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,WAAW,CAC/B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,GACjC,OAAO,CAAC,IAAI,CAAC,CAoCf;AAmCD;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,OAAO,CAAE,MAAM,EAAE,oBAAoB,sDAO1D"}

package/types/extractor/core/key-finder.d.ts

@@ -0,0 +1,31 @@
+import type { ExtractedKey, Logger, I18nextToolkitConfig } from '../../types';
+/**
+ * Main function for finding translation keys across all source files in a project.
+ *
+ * This function orchestrates the key extraction process:
+ * 1. Processes source files based on input patterns
+ * 2. Initializes and manages plugins
+ * 3. Processes each file through AST parsing and key extraction
+ * 4. Runs plugin lifecycle hooks
+ * 5. Returns a deduplicated map of all found keys
+ *
+ * @param config - The i18next toolkit configuration object
+ * @param logger - Logger instance for output (defaults to ConsoleLogger)
+ * @returns Promise resolving to a Map of unique translation keys with metadata
+ *
+ * @example
+ * ```typescript
+ * const config = {
+ *   extract: {
+ *     input: ['src/**\/*.{ts,tsx}'],
+ *     functions: ['t'],
+ *     transComponents: ['Trans']
+ *   }
+ * }
+ *
+ * const keys = await findKeys(config)
+ * console.log(`Found ${keys.size} unique translation keys`)
+ * ```
+ */
+export declare function findKeys(config: I18nextToolkitConfig, logger?: Logger): Promise<Map<string, ExtractedKey>>;
+//# sourceMappingURL=key-finder.d.ts.map

package/types/extractor/core/key-finder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"key-finder.d.ts","sourceRoot":"","sources":["../../../src/extractor/core/key-finder.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AAK7E;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAsB,QAAQ,CAC5B,MAAM,EAAE,oBAAoB,EAC5B,MAAM,GAAE,MAA4B,GACnC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAgBpC"}

package/types/extractor/core/translation-manager.d.ts

@@ -0,0 +1,31 @@
+import { TranslationResult, ExtractedKey, I18nextToolkitConfig } from '../../types';
+/**
+ * Processes extracted translation keys and generates translation files for all configured locales.
+ *
+ * This function:
+ * 1. Groups keys by namespace
+ * 2. For each locale and namespace combination:
+ *    - Reads existing translation files
+ *    - Preserves keys matching `preservePatterns`
+ *    - Merges in newly extracted keys
+ *    - Uses primary language defaults or empty strings for secondary languages
+ *    - Maintains key sorting based on configuration
+ * 3. Determines if files need updating by comparing content
+ *
+ * @param keys - Map of extracted translation keys with metadata
+ * @param config - The i18next toolkit configuration object
+ * @returns Promise resolving to array of translation results with update status
+ *
+ * @example
+ * ```typescript
+ * const keys = new Map([
+ *   ['translation:welcome', { key: 'welcome', defaultValue: 'Welcome!', ns: 'translation' }],
+ *   ['common:button.save', { key: 'button.save', defaultValue: 'Save', ns: 'common' }]
+ * ])
+ *
+ * const results = await getTranslations(keys, config)
+ * // Results contain update status and new/existing translations for each locale
+ * ```
+ */
+export declare function getTranslations(keys: Map<string, ExtractedKey>, config: I18nextToolkitConfig): Promise<TranslationResult[]>;
+//# sourceMappingURL=translation-manager.d.ts.map

package/types/extractor/core/translation-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translation-manager.d.ts","sourceRoot":"","sources":["../../../src/extractor/core/translation-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AAiBnF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,EAC/B,MAAM,EAAE,oBAAoB,GAC3B,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAkE9B"}

package/types/extractor/index.d.ts

@@ -0,0 +1,8 @@
+export * from './core/extractor';
+export * from './core/key-finder';
+export * from './core/translation-manager';
+export * from './parsers/ast-visitors';
+export * from './parsers/comment-parser';
+export * from './parsers/jsx-parser';
+export * from './plugin-manager';
+//# sourceMappingURL=index.d.ts.map

package/types/extractor/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/extractor/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAA;AAChC,cAAc,mBAAmB,CAAA;AACjC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,wBAAwB,CAAA;AACtC,cAAc,0BAA0B,CAAA;AACxC,cAAc,sBAAsB,CAAA;AACpC,cAAc,kBAAkB,CAAA"}

package/types/extractor/parsers/ast-visitors.d.ts

@@ -0,0 +1,235 @@
+import type { Module } from '@swc/core';
+import type { PluginContext, I18nextToolkitConfig, Logger } from '../../types';
+/**
+ * AST visitor class that traverses JavaScript/TypeScript syntax trees to extract translation keys.
+ *
+ * This class implements a manual recursive walker that:
+ * - Maintains scope information for tracking useTranslation and getFixedT calls
+ * - Extracts keys from t() function calls with various argument patterns
+ * - Handles JSX Trans components with complex children serialization
+ * - Supports both string literals and selector API for type-safe keys
+ * - Processes pluralization and context variants
+ * - Manages namespace resolution from multiple sources
+ *
+ * The visitor respects configuration options for separators, function names,
+ * component names, and other extraction settings.
+ *
+ * @example
+ * ```typescript
+ * const visitors = new ASTVisitors(config, pluginContext, logger)
+ * visitors.visit(parsedAST)
+ *
+ * // The pluginContext will now contain all extracted keys
+ * ```
+ */
+export declare class ASTVisitors {
+    private readonly pluginContext;
+    private readonly config;
+    private readonly logger;
+    private scopeStack;
+    /**
+     * Creates a new AST visitor instance.
+     *
+     * @param config - Toolkit configuration with extraction settings
+     * @param pluginContext - Context for adding discovered translation keys
+     * @param logger - Logger for warnings and debug information
+     */
+    constructor(config: I18nextToolkitConfig, pluginContext: PluginContext, logger: Logger);
+    /**
+     * Main entry point for AST traversal.
+     * Creates a root scope and begins the recursive walk through the syntax tree.
+     *
+     * @param node - The root module node to traverse
+     */
+    visit(node: Module): void;
+    /**
+     * Recursively walks through AST nodes, handling scoping and visiting logic.
+     *
+     * This is the core traversal method that:
+     * 1. Manages function scopes (enter/exit)
+     * 2. Dispatches to specific handlers based on node type
+     * 3. Recursively processes child nodes
+     * 4. Maintains proper scope cleanup
+     *
+     * @param node - The current AST node to process
+     *
+     * @private
+     */
+    private walk;
+    /**
+     * Enters a new variable scope by pushing a new scope map onto the stack.
+     * Used when entering functions to isolate variable declarations.
+     *
+     * @private
+     */
+    private enterScope;
+    /**
+     * Exits the current variable scope by popping the top scope map.
+     * Used when leaving functions to clean up variable tracking.
+     *
+     * @private
+     */
+    private exitScope;
+    /**
+     * Stores variable information in the current scope.
+     * Used to track translation functions and their configuration.
+     *
+     * @param name - Variable name to store
+     * @param info - Scope information about the variable
+     *
+     * @private
+     */
+    private setVarInScope;
+    /**
+     * Retrieves variable information from the scope chain.
+     * Searches from innermost to outermost scope.
+     *
+     * @param name - Variable name to look up
+     * @returns Scope information if found, undefined otherwise
+     *
+     * @private
+     */
+    private getVarFromScope;
+    /**
+     * Handles variable declarations that might define translation functions.
+     *
+     * Processes two patterns:
+     * 1. `const { t } = useTranslation(...)` - React i18next pattern
+     * 2. `const t = i18next.getFixedT(...)` - Core i18next pattern
+     *
+     * Extracts namespace and key prefix information for later use.
+     *
+     * @param node - Variable declarator node to process
+     *
+     * @private
+     */
+    private handleVariableDeclarator;
+    /**
+     * Processes useTranslation hook declarations to extract scope information.
+     *
+     * Handles various destructuring patterns:
+     * - `const [t] = useTranslation('ns')` - Array destructuring
+     * - `const { t } = useTranslation('ns')` - Object destructuring
+     * - `const { t: myT } = useTranslation('ns')` - Aliased destructuring
+     *
+     * Extracts namespace from the first argument and keyPrefix from options.
+     *
+     * @param node - Variable declarator with useTranslation call
+     *
+     * @private
+     */
+    private handleUseTranslationDeclarator;
+    /**
+     * Processes getFixedT function declarations to extract scope information.
+     *
+     * Handles the pattern: `const t = i18next.getFixedT(lng, ns, keyPrefix)`
+     * - Ignores the first argument (language)
+     * - Extracts namespace from the second argument
+     * - Extracts key prefix from the third argument
+     *
+     * @param node - Variable declarator with getFixedT call
+     *
+     * @private
+     */
+    private handleGetFixedTDeclarator;
+    /**
+     * Processes function call expressions to extract translation keys.
+     *
+     * This is the core extraction method that handles:
+     * - Standard t() calls with string literals
+     * - Selector API calls with arrow functions: `t($ => $.path.to.key)`
+     * - Namespace resolution from multiple sources
+     * - Default value extraction from various argument patterns
+     * - Pluralization and context handling
+     * - Key prefix application from scope
+     *
+     * @param node - Call expression node to process
+     *
+     * @private
+     */
+    private handleCallExpression;
+    /**
+     * Generates plural form keys based on the primary language's plural rules.
+     *
+     * Uses Intl.PluralRules to determine the correct plural categories
+     * for the configured primary language and generates suffixed keys
+     * for each category (e.g., 'item_one', 'item_other').
+     *
+     * @param key - Base key name for pluralization
+     * @param defaultValue - Default value to use for all plural forms
+     * @param ns - Namespace for the keys
+     *
+     * @private
+     */
+    private handlePluralKeys;
+    /**
+     * Extracts default value from translation function call arguments.
+     *
+     * Supports multiple patterns:
+     * - String as second argument: `t('key', 'Default')`
+     * - Object with defaultValue: `t('key', { defaultValue: 'Default' })`
+     * - Falls back to the key itself if no default found
+     *
+     * @param node - Call expression node
+     * @param fallback - Fallback value if no default found
+     * @returns Extracted default value
+     *
+     * @private
+     */
+    private getDefaultValue;
+    /**
+     * Processes JSX elements to extract translation keys from Trans components.
+     *
+     * Identifies configured Trans components and delegates to the JSX parser
+     * for complex children serialization and attribute extraction.
+     *
+     * @param node - JSX element node to process
+     *
+     * @private
+     */
+    private handleJSXElement;
+    /**
+     * Extracts element name from JSX opening tag.
+     *
+     * Handles both simple identifiers and member expressions:
+     * - `<Trans>` → 'Trans'
+     * - `<React.Trans>` → 'React.Trans'
+     *
+     * @param node - JSX element node
+     * @returns Element name or undefined if not extractable
+     *
+     * @private
+     */
+    private getElementName;
+    /**
+     * Extracts string value from object property.
+     *
+     * Looks for properties by name and returns their string values.
+     * Used for extracting options like 'ns', 'defaultValue', 'context', etc.
+     *
+     * @param object - Object expression to search
+     * @param propName - Property name to find
+     * @returns String value if found, empty string if property exists but isn't a string, undefined if not found
+     *
+     * @private
+     */
+    private getObjectPropValue;
+    /**
+     * Extracts translation key from selector API arrow function.
+     *
+     * Processes selector expressions like:
+     * - `$ => $.path.to.key` → 'path.to.key'
+     * - `$ => $.app['title'].main` → 'app.title.main'
+     * - `$ => { return $.nested.key; }` → 'nested.key'
+     *
+     * Handles both dot notation and bracket notation, respecting
+     * the configured key separator or flat key structure.
+     *
+     * @param node - Arrow function expression from selector call
+     * @returns Extracted key path or null if not statically analyzable
+     *
+     * @private
+     */
+    private extractKeyFromSelector;
+}
+//# sourceMappingURL=ast-visitors.d.ts.map

package/types/extractor/parsers/ast-visitors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-visitors.d.ts","sourceRoot":"","sources":["../../../src/extractor/parsers/ast-visitors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAmG,MAAM,WAAW,CAAA;AACxI,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAc9E;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAe;IAC7C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;IAC7C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;IAC/B,OAAO,CAAC,UAAU,CAAoC;IAEtD;;;;;;OAMG;gBAED,MAAM,EAAE,oBAAoB,EAC5B,aAAa,EAAE,aAAa,EAC5B,MAAM,EAAE,MAAM;IAOhB;;;;;OAKG;IACI,KAAK,CAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAMjC;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,IAAI;IAiDZ;;;;;OAKG;IACH,OAAO,CAAC,UAAU;IAIlB;;;;;OAKG;IACH,OAAO,CAAC,SAAS;IAIjB;;;;;;;;OAQG;IACH,OAAO,CAAC,aAAa;IAMrB;;;;;;;;OAQG;IACH,OAAO,CAAC,eAAe;IASvB;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,wBAAwB;IAqBhC;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,8BAA8B;IAiDtC;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,yBAAyB;IAoBjC;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,oBAAoB;IAkE5B;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,gBAAgB;IAmBxB;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,eAAe;IAgBvB;;;;;;;;;OASG;IACH,OAAO,CAAC,gBAAgB;IA8CxB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,cAAc;IAgBtB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,kBAAkB;IAuB1B;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,sBAAsB;CA0C/B"}

package/types/extractor/parsers/comment-parser.d.ts

@@ -0,0 +1,24 @@
+import type { PluginContext, I18nextToolkitConfig } from '../../types';
+/**
+ * Extracts translation keys from comments in source code using regex patterns.
+ * Supports extraction from single-line (//) and multi-line comments.
+ *
+ * @param code - The source code to analyze
+ * @param functionNames - Array of function names to look for (e.g., ['t', 'i18n.t'])
+ * @param pluginContext - Context object with helper methods to add found keys
+ * @param config - Configuration object containing extraction settings
+ *
+ * @example
+ * ```typescript
+ * const code = `
+ *   // t('user.name', 'User Name')
+ *   /* t('app.title', { defaultValue: 'My App', ns: 'common' }) *\/
+ * `
+ *
+ * const context = createPluginContext(allKeys)
+ * extractKeysFromComments(code, ['t'], context, config)
+ * // Extracts: user.name and app.title with their respective settings
+ * ```
+ */
+export declare function extractKeysFromComments(code: string, functionNames: string[], pluginContext: PluginContext, config: I18nextToolkitConfig): void;
+//# sourceMappingURL=comment-parser.d.ts.map

package/types/extractor/parsers/comment-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"comment-parser.d.ts","sourceRoot":"","sources":["../../../src/extractor/parsers/comment-parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AAEtE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,MAAM,EAAE,EACvB,aAAa,EAAE,aAAa,EAC5B,MAAM,EAAE,oBAAoB,GAC3B,IAAI,CA+BN"}

package/types/extractor/parsers/jsx-parser.d.ts

@@ -0,0 +1,35 @@
+import type { JSXElement } from '@swc/core';
+import type { ExtractedKey, I18nextToolkitConfig } from '../../types';
+/**
+ * Extracts translation keys from JSX Trans components.
+ *
+ * This function handles various Trans component patterns:
+ * - Explicit i18nKey prop: `<Trans i18nKey="my.key">content</Trans>`
+ * - Implicit keys from children: `<Trans>Hello World</Trans>`
+ * - Namespace specification: `<Trans ns="common">content</Trans>`
+ * - Default values: `<Trans defaults="Default text">content</Trans>`
+ * - Pluralization: `<Trans count={count}>content</Trans>`
+ * - HTML preservation: `<Trans>Hello <strong>world</strong></Trans>`
+ *
+ * @param node - The JSX element node to process
+ * @param config - The toolkit configuration containing extraction settings
+ * @returns Extracted key information or null if no valid key found
+ *
+ * @example
+ * ```typescript
+ * // Input JSX:
+ * // <Trans i18nKey="welcome.title" ns="home" defaults="Welcome!">
+ * //   Welcome to our <strong>amazing</strong> app!
+ * // </Trans>
+ *
+ * const result = extractFromTransComponent(jsxNode, config)
+ * // Returns: {
+ * //   key: 'welcome.title',
+ * //   ns: 'home',
+ * //   defaultValue: 'Welcome!',
+ * //   hasCount: false
+ * // }
+ * ```
+ */
+export declare function extractFromTransComponent(node: JSXElement, config: I18nextToolkitConfig): ExtractedKey | null;
+//# sourceMappingURL=jsx-parser.d.ts.map

package/types/extractor/parsers/jsx-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsx-parser.d.ts","sourceRoot":"","sources":["../../../src/extractor/parsers/jsx-parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAC3C,OAAO,KAAK,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AAErE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,yBAAyB,CAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,oBAAoB,GAAG,YAAY,GAAG,IAAI,CAkD9G"}

package/types/extractor/plugin-manager.d.ts

@@ -0,0 +1,37 @@
+import type { ExtractedKey, PluginContext } from '../types';
+/**
+ * Initializes an array of plugins by calling their setup hooks.
+ * This function should be called before starting the extraction process.
+ *
+ * @param plugins - Array of plugin objects to initialize
+ *
+ * @example
+ * ```typescript
+ * const plugins = [customPlugin(), anotherPlugin()]
+ * await initializePlugins(plugins)
+ * // All plugin setup hooks have been called
+ * ```
+ */
+export declare function initializePlugins(plugins: any[]): Promise<void>;
+/**
+ * Creates a plugin context object that provides helper methods for plugins.
+ * The context allows plugins to add extracted keys to the main collection.
+ *
+ * @param allKeys - The main map where extracted keys are stored
+ * @returns A context object with helper methods for plugins
+ *
+ * @example
+ * ```typescript
+ * const allKeys = new Map()
+ * const context = createPluginContext(allKeys)
+ *
+ * // Plugin can now add keys
+ * context.addKey({
+ *   key: 'my.custom.key',
+ *   defaultValue: 'Default Value',
+ *   ns: 'common'
+ * })
+ * ```
+ */
+export declare function createPluginContext(allKeys: Map<string, ExtractedKey>): PluginContext;
+//# sourceMappingURL=plugin-manager.d.ts.map

package/types/extractor/plugin-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-manager.d.ts","sourceRoot":"","sources":["../../src/extractor/plugin-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAE3D;;;;;;;;;;;;GAYG;AACH,wBAAsB,iBAAiB,CAAE,OAAO,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAItE;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,mBAAmB,CAAE,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,aAAa,CAYtF"}

package/types/extractor.d.ts

@@ -0,0 +1,7 @@
+import { runExtractor, extract } from './extractor/core/extractor';
+import { findKeys } from './extractor/core/key-finder';
+import { getTranslations } from './extractor/core/translation-manager';
+import { ASTVisitors } from './extractor/parsers/ast-visitors';
+import type { PluginContext } from './types';
+export { runExtractor, extract, findKeys, getTranslations, ASTVisitors, PluginContext, };
+//# sourceMappingURL=extractor.d.ts.map

package/types/extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractor.d.ts","sourceRoot":"","sources":["../src/extractor.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAA;AAClE,OAAO,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAA;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,sCAAsC,CAAA;AACtE,OAAO,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAA;AAC9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAE5C,OAAO,EACL,YAAY,EACZ,OAAO,EACP,QAAQ,EACR,eAAe,EACf,WAAW,EACX,aAAa,GACd,CAAA"}