i18next Parser

When translating an application, maintaining the translation catalog by hand is painful. This package parses your code and automates this process.

Finally, if you want to make this process even less painful, I invite you to check Locize. They are a sponsor of this project. Actually, if you use this package and like it, supporting me on Patreon would mean a great deal!

Features

• Choose your weapon: A CLI, a standalone parser or a stream transform
• 5 built in lexers: Javascript, JSX, HTML, Handlebars, and TypeScript+tsx
• Handles VueJS 3.0 (.vue) files
• Creates one catalog file per locale and per namespace
• Backs up the old keys your code doesn't use anymore in namespace_old.json catalog
• Restores keys from the _old file if the one in the translation file is empty
• Parses comments for static keys to support dynamic key translations.
• Supports i18next features:
  • Context: keys of the form key_context
  • Plural: keys of the form key_zero, key_one, key_two, key_few, key_many and key_other as described here

Versions

You can find information about major releases on the dedicated page. The migration documentation will help you figure out the breaking changes between versions.

• 9.x is tested on Node 18, 20 and 22.
• 8.x is tested on Node 16, 18 and 20.
• 7.x is tested on Node 14, 16 and 18.
• 6.x is tested on Node 14 and 16.

Usage

CLI

You can use the CLI with the package installed locally but if you want to use it from anywhere, you better install it globally:

yarn global add i18next-parser
npm install -g i18next-parser
i18next 'app/**/*.{js,hbs}' 'lib/**/*.{js,hbs}' [-oc]

Multiple globbing patterns are supported to specify complex file selections. You can learn how to write globs here. Note that glob must be wrapped with single quotes when passed as arguments.

IMPORTANT NOTE: If you pass the globs as CLI argument, they must be relative to where you run the command (aka relative to process.cwd()). If you pass the globs via the input option of the config file, they must be relative to the config file.

• -c, --config : Path to the config file (default: i18next-parser.config.{js,mjs,json,ts,yaml,yml}).
• -o, --output : Path to the output directory (default: locales/$LOCALE/$NAMESPACE.json).
• -s, --silent: Disable logging to stdout.
• --fail-on-warnings: Exit with an exit code of 1 on warnings
• --fail-on-update: Exit with an exit code of 1 when translations are updated (for CI purpose)

Gulp

Save the package to your devDependencies:

yarn add -D i18next-parser
npm install --save-dev i18next-parser

Gulp defines itself as the streaming build system. Put simply, it is like Grunt, but performant and elegant.

1import { gulp as i18nextParser } from 'i18next-parser'
2
3gulp.task('i18next', function () {
4  gulp
5    .src('app/**')
6    .pipe(
7      new i18nextParser({
8        locales: ['en', 'de'],
9        output: 'locales/$LOCALE/$NAMESPACE.json',
10      })
11    )
12    .pipe(gulp.dest('./'))
13})

IMPORTANT: output is required to know where to read the catalog from. You might think that gulp.dest() is enough though it does not inform the transform where to read the existing catalog from.

Broccoli

Save the package to your devDependencies:

yarn add -D i18next-parser
npm install --save-dev i18next-parser

Broccoli.js defines itself as a fast, reliable asset pipeline, supporting constant-time rebuilds and compact build definitions.

1import Funnel from 'broccoli-funnel'
2import { broccoli as i18nextParser } from 'i18next-parser'
3
4const appRoot = 'broccoli'
5
6let i18n = new Funnel(appRoot, {
7  files: ['handlebars.hbs', 'javascript.js'],
8  annotation: 'i18next-parser',
9})
10
11i18n = new i18nextParser([i18n], {
12  output: 'broccoli/locales/$LOCALE/$NAMESPACE.json',
13})
14
15export default i18n

Note: You may need to configure Broccoli to place temporary files (option: tmpdir) within the current working directory as I18next-parser does not traverse down beyond that.

Options

Using a config file gives you fine-grained control over how i18next-parser treats your files. Here's an example config showing all config options with their defaults.

1// i18next-parser.config.js
2
3export default {
4  contextSeparator: '_',
5  // Key separator used in your translation keys
6
7  createOldCatalogs: true,
8  // Save the \_old files
9
10  defaultNamespace: 'translation',
11  // Default namespace used in your i18next config
12
13  defaultValue: '',
14  // Default value to give to keys with no value
15  // You may also specify a function accepting the locale, namespace, key, and value as arguments
16
17  indentation: 2,
18  // Indentation of the catalog files
19
20  keepRemoved: false,
21  // Keep keys from the catalog that are no longer in code
22  // You may either specify a boolean to keep or discard all removed keys.
23  // You may also specify an array of patterns: the keys from the catalog that are no long in the code but match one of the patterns will be kept.
24  // The patterns are applied to the full key including the namespace, the parent keys and the separators.
25
26  keySeparator: '.',
27  // Key separator used in your translation keys
28  // If you want to use plain english keys, separators such as `.` and `:` will conflict. You might want to set `keySeparator: false` and `namespaceSeparator: false`. That way, `t('Status: Loading...')` will not think that there are a namespace and three separator dots for instance.
29
30  // see below for more details
31  lexers: {
32    hbs: ['HandlebarsLexer'],
33    handlebars: ['HandlebarsLexer'],
34
35    htm: ['HTMLLexer'],
36    html: ['HTMLLexer'],
37
38    mjs: ['JavascriptLexer'],
39    js: ['JavascriptLexer'], // if you're writing jsx inside .js files, change this to JsxLexer
40    ts: ['JavascriptLexer'],
41    jsx: ['JsxLexer'],
42    tsx: ['JsxLexer'],
43
44    default: ['JavascriptLexer'],
45  },
46
47  lineEnding: 'auto',
48  // Control the line ending. See options at https://github.com/ryanve/eol
49
50  locales: ['en', 'fr'],
51  // An array of the locales in your applications
52
53  namespaceSeparator: ':',
54  // Namespace separator used in your translation keys
55  // If you want to use plain english keys, separators such as `.` and `:` will conflict. You might want to set `keySeparator: false` and `namespaceSeparator: false`. That way, `t('Status: Loading...')` will not think that there are a namespace and three separator dots for instance.
56
57  output: 'locales/$LOCALE/$NAMESPACE.json',
58  // Supports $LOCALE and $NAMESPACE injection
59  // Supports JSON (.json) and YAML (.yml) file formats
60  // Where to write the locale files relative to process.cwd()
61
62  pluralSeparator: '_',
63  // Plural separator used in your translation keys
64  // If you want to use plain english keys, separators such as `_` might conflict. You might want to set `pluralSeparator` to a different string that does not occur in your keys.
65  // If you don't want to generate keys for plurals (for example, in case you are using ICU format), set `pluralSeparator: false`.
66
67  input: undefined,
68  // An array of globs that describe where to look for source files
69  // relative to the location of the configuration file
70
71  sort: false,
72  // Whether or not to sort the catalog. Can also be a [compareFunction](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#parameters)
73
74  verbose: false,
75  // Display info about the parsing including some stats
76
77  failOnWarnings: false,
78  // Exit with an exit code of 1 on warnings
79
80  failOnUpdate: false,
81  // Exit with an exit code of 1 when translations are updated (for CI purpose)
82
83  customValueTemplate: null,
84  // If you wish to customize the value output the value as an object, you can set your own format.
85  //
86  // - ${defaultValue} is the default value you set in your translation function.
87  // - ${filePaths} will be expanded to an array that contains the absolute
88  //   file paths where the translations originated in, in case e.g., you need
89  //   to provide translators with context
90  //
91  // Any other custom property will be automatically extracted from the 2nd
92  // argument of your `t()` function or tOptions in <Trans tOptions={...} />
93  //
94  // Example:
95  // For `t('my-key', {maxLength: 150, defaultValue: 'Hello'})` in
96  // /path/to/your/file.js,
97  //
98  // Using the following customValueTemplate:
99  //
100  // customValueTemplate: {
101  //   message: "${defaultValue}",
102  //   description: "${maxLength}",
103  //   paths: "${filePaths}",
104  // }
105  //
106  // Will result in the following item being extracted:
107  //
108  // "my-key": {
109  //   "message": "Hello",
110  //   "description": 150,
111  //   "paths": ["/path/to/your/file.js"]
112  // }
113
114  resetDefaultValueLocale: null,
115  // The locale to compare with default values to determine whether a default value has been changed.
116  // If this is set and a default value differs from a translation in the specified locale, all entries
117  // for that key across locales are reset to the default value, and existing translations are moved to
118  // the `_old` file.
119
120  i18nextOptions: null,
121  // If you wish to customize options in internally used i18next instance, you can define an object with any
122  // configuration property supported by i18next (https://www.i18next.com/overview/configuration-options).
123  // { compatibilityJSON: 'v3' } can be used to generate v3 compatible plurals.
124
125  yamlOptions: null,
126  // If you wish to customize options for yaml output, you can define an object here.
127  // Configuration options are here (https://github.com/nodeca/js-yaml#dump-object---options-).
128  // Example:
129  // {
130  //   lineWidth: -1,
131  // }
132}

Lexers

The lexers option let you configure which Lexer to use for which extension. Here is the default:

Note the presence of a default which will catch any extension that is not listed. There are 4 lexers available: HandlebarsLexer, HTMLLexer, JavascriptLexer and JsxLexer. Each has configurations of its own. Typescript is supported via JavascriptLexer and JsxLexer. If you need to change the defaults, you can do it like so:

Javascript

The Javascript lexer uses Typescript compiler to walk through your code and extract translation functions.

The default configuration is below:

1{
2  // JavascriptLexer default config (js, mjs)
3  js: [{
4    lexer: 'JavascriptLexer',
5    functions: ['t'], // Array of functions to match
6    namespaceFunctions: ['useTranslation', 'withTranslation'], // Array of functions to match for namespace
7  }],
8}

Jsx

The JSX lexer builds off of the Javascript lexer and extends it with support for JSX syntax.

Default configuration:

1{
2  // JsxLexer default config (jsx)
3  // JsxLexer can take all the options of the JavascriptLexer plus the following
4  jsx: [{
5    lexer: 'JsxLexer',
6    attr: 'i18nKey', // Attribute for the keys
7    componentFunctions: ['Trans'], // Array of components to match
8  }],
9}

If your JSX files have .js extension (e.g. create-react-app projects) you should override the default js lexer with JsxLexer to enable jsx parsing from js files:

1{
2  js: [{
3    lexer: 'JsxLexer'
4  }],
5}

Supporting helper functions in Trans tags

If you're working with i18next in Typescript, you might be using a helper function to make sure that objects in components pass the typechecker: e.g.,

1const SomeComponent = (props) => (
2  <Trans>
3    Visit
4    <Link to='/user/john'>{castAsString({ name: props.name })}'s profile</Link>
5    {/* Equivalent to, but resolves typechecker errors with */}
6    <Link to='/user/john'>{{ name: props.name }}'s profile</Link>
7  </Trans>
8)
9
10function castAsString(record: Record<string, unknown>): string {
11  return record as unknown as string
12}

In order for the parser to extract variables properly, you can add a list of such functions to the lexer options:

{
  js: [{
    lexer: 'JsxLexer',
    transIdentityFunctionsToIgnore: ['castAsString']
  }],
}

Ts(x)

Typescript is supported via Javascript and Jsx lexers. If you are using Javascript syntax (e.g. with React), follow the steps in Jsx section, otherwise Javascript section.

Handlebars

1{
2  // HandlebarsLexer default config (hbs, handlebars)
3  handlebars: [
4    {
5      lexer: 'HandlebarsLexer',
6      functions: ['t'], // Array of functions to match
7    },
8  ]
9}

Html

1{
2  // HTMLLexer default config (htm, html)
3  html: [{
4    lexer: 'HTMLLexer',
5    attr: 'data-i18n' // Attribute for the keys
6    optionAttr: 'data-i18n-options' // Attribute for the options
7  }]
8}

Custom lexers

You can provide function instead of string as a custom lexer.

1import CustomJsLexer from './CustomJsLexer';
2
3// ...
4{
5  js: [CustomJsLexer],
6  jsx: [{
7    lexer: CustomJsLexer,
8    customOption: true // Custom attribute passed to CustomJsLexer class constructor
9  }]
10}
11// ...

Caveats

While i18next extracts translation keys in runtime, i18next-parser doesn't run the code, so it can't interpolate values in these expressions:

t(key)
t('key' + id)
t(`key${id}`)

As a workaround you should specify possible static values in comments anywhere in your file:

// t('key_1')
// t('key_2')
t(key)

/*
t('key1')
t('key2')
*/
t('key' + id)

Events

The transform emits a reading event for each file it parses:

.pipe( i18next().on('reading', (file) => {}) )

The transform emits a error:json event if the JSON.parse on json files fail:

.pipe( i18next().on('error:json', (path, error) => {}) )

The transform emits a warning event if the file has a key that is not a string litteral or an option object with a spread operator:

.pipe( i18next().on('warning', (path, key) => {}) )

Here is a list of the warnings:

• Key is not a string literal: the parser cannot parse variables, only literals. If your code contains something like t(variable), the parser will throw a warning.
• Found same keys with different values: if you use different default values for the same key, you'll get this error. For example, having t('key', {defaultValue: 'foo'}) and t('key', {defaultValue: 'bar'}). The parser will select the latest one.
• Found translation key already mapped to a map or parent of new key already mapped to a string: happens in this kind of situation: t('parent', {defaultValue: 'foo'}) and t('parent.child', {defaultValue: 'bar'}). parent is both a translation and an object for child.

Contribute

Any contribution is welcome. Please read the guidelines first.

Thanks a lot to all the previous contributors.

If you use this package and like it, supporting me on Patreon is another great way to contribute!

---

Gold Sponsors