Missing translation string

Author: MartijnCuppens

README.md

@@ -36,6 +36,7 @@
   - [`separator`](#separator)
   - [`exclude`](#exclude)
   - [`noEmptyTranslation`](#noemptytranslation)
+  - [`missingtranslationstring`](#missingtranslationstring)
 - [Supported `vue-i18n` Formats](#supported-vue-i18n-formats)
 - [Why?](#why)
 - [Contribution](#contribution)
@@ -208,6 +209,18 @@ You can generate a default configuration file using `npx vue-i18n-extract init`
   * `'en'`: Generate empty default translation for locale `'en'`.
   * `'en-US'`: Generate empty default translation for locale `'en-US'`.
 
+### `missingTranslationString`
+
+* Name: `missingTranslationString`
+* CLI argument: `--missing-translation-string`, `--missingTranslationString`
+* Required: No
+* Default: `''`
+* Type: `string` or `null`
+* Description: Text to use when missing translations are added to the translation files.
+* Examples:
+  * `'Translation missing'`: Use "Translation missing" as default key.
+  * `null`: Add the translation key to the file, but don't add a default translation. This will trigger `vue-i18n`'s the missingHandler.
+
 ## Supported `vue-i18n` Formats
 
 - Static in template or script:

bin/vue-i18n-extract.js

@@ -43,6 +43,10 @@ cli
     '--noEmptyTranslation',
     'Use if you want to generate a default translated string by using the key itself'
    )
+  .option(
+    '--missingTranslationString',
+    'Default string for missing translations.'
+   )
    .option(
     '--detect <detectionType>',
     '[string] The type of issues you want to detect (ex. --detect missing) ',

dist/config-file/vue-i18n-extract.config.d.ts

@@ -8,5 +8,6 @@ declare const _default: {
     ci: boolean;
     separator: string;
     noEmptyTranslation: string;
+    missingTranslationString: string;
 };
 export default _default;

dist/create-report/language-files.d.ts

@@ -2,6 +2,6 @@
 import { SimpleFile, I18NLanguage, I18NItem } from '../types';
 export declare function readLanguageFiles(src: string): SimpleFile[];
 export declare function extractI18NLanguageFromLanguageFiles(languageFiles: SimpleFile[], dot?: DotObject.Dot): I18NLanguage;
-export declare function writeMissingToLanguageFiles(parsedLanguageFiles: SimpleFile[], missingKeys: I18NItem[], dot?: DotObject.Dot, noEmptyTranslation?: string): void;
+export declare function writeMissingToLanguageFiles(parsedLanguageFiles: SimpleFile[], missingKeys: I18NItem[], dot?: DotObject.Dot, noEmptyTranslation?: string, missingTranslationString?: string): void;
 export declare function removeUnusedFromLanguageFiles(parsedLanguageFiles: SimpleFile[], unusedKeys: I18NItem[], dot?: DotObject.Dot): void;
 export declare function parselanguageFiles(languageFiles: string, dot?: DotObject.Dot): I18NLanguage;

dist/create-report/report.d.ts

@@ -1,4 +1,4 @@
 /// <reference types="node" />
-import { I18NItemWithBounding, I18NLanguage, I18NReport } from '../types';
-export declare function extractI18NReport(vueItems: I18NItemWithBounding[], languageFiles: I18NLanguage): I18NReport;
+import { DetectionType, I18NItemWithBounding, I18NLanguage, I18NReport } from '../types';
+export declare function extractI18NReport(vueItems: I18NItemWithBounding[], languageFiles: I18NLanguage, detect: DetectionType[]): I18NReport;
 export declare function writeReportToFile(report: I18NReport, writePath: string): Promise<NodeJS.ErrnoException | void>;

dist/types.d.ts

@@ -8,7 +8,14 @@ export declare type ReportOptions = {
     ci?: boolean;
     separator?: string;
     noEmptyTranslation?: string;
+    missingTranslationString?: string;
+    detect?: DetectionType[];
 };
+export declare enum DetectionType {
+    Missing = "missing",
+    Unused = "unused",
+    Dynamic = "dynamic"
+}
 export declare type SimpleFile = {
     fileName: string;
     path: string;

dist/vue-i18n-extract.modern.mjs

@@ -34,7 +34,8 @@ var defaultConfig = {
   remove: false,
   ci: false,
   separator: '.',
-  noEmptyTranslation: ''
+  noEmptyTranslation: '',
+  missingTranslationString: ''
 };
 
 function initCommand() {
@@ -61,6 +62,14 @@ function resolveConfig() {
   return options;
 }
 
+var DetectionType;
+
+(function (DetectionType) {
+  DetectionType["Missing"] = "missing";
+  DetectionType["Unused"] = "unused";
+  DetectionType["Dynamic"] = "dynamic";
+})(DetectionType || (DetectionType = {}));
+
 function readVueFiles(src) {
   // Replace backslash path segments to make the path work with the glob package.
   // https://github.com/Spittal/vue-i18n-extract/issues/159
@@ -218,13 +227,13 @@ function extractI18NLanguageFromLanguageFiles(languageFiles, dot = Dot) {
     return accumulator;
   }, {});
 }
-function writeMissingToLanguageFiles(parsedLanguageFiles, missingKeys, dot = Dot, noEmptyTranslation = '') {
+function writeMissingToLanguageFiles(parsedLanguageFiles, missingKeys, dot = Dot, noEmptyTranslation = '', missingTranslationString = '') {
   parsedLanguageFiles.forEach(languageFile => {
     const languageFileContent = JSON.parse(languageFile.content);
     missingKeys.forEach(item => {
       if (item.language && languageFile.fileName.includes(item.language) || !item.language) {
         const addDefaultTranslation = noEmptyTranslation && (noEmptyTranslation === '*' || noEmptyTranslation === item.language);
-        dot.str(item.path, addDefaultTranslation ? item.path : '', languageFileContent);
+        dot.str(item.path, addDefaultTranslation ? item.path : missingTranslationString === 'null' ? null : missingTranslationString, languageFileContent);
       }
     });
     writeLanguageFile(languageFile, languageFileContent);
@@ -278,20 +287,31 @@ function mightBeDynamic(item) {
 } // Looping through the arays multiple times might not be the most effecient, but it's the easiest to read and debug. Which at this scale is an accepted trade-off.
 
 
-function extractI18NReport(vueItems, languageFiles) {
+function extractI18NReport(vueItems, languageFiles, detect) {
   const missingKeys = [];
   const unusedKeys = [];
-  const maybeDynamicKeys = vueItems.filter(vueItem => mightBeDynamic(vueItem)).map(vueItem => stripBounding(vueItem));
+  const maybeDynamicKeys = [];
+
+  if (detect.includes(DetectionType.Dynamic)) {
+    maybeDynamicKeys.push(...vueItems.filter(vueItem => mightBeDynamic(vueItem)).map(vueItem => stripBounding(vueItem)));
+  }
+
   Object.keys(languageFiles).forEach(language => {
     const languageItems = languageFiles[language];
-    const missingKeysInLanguage = vueItems.filter(vueItem => !mightBeDynamic(vueItem)).filter(vueItem => !languageItems.some(languageItem => vueItem.path === languageItem.path)).map(vueItem => _extends({}, stripBounding(vueItem), {
-      language
-    }));
-    const unusedKeysInLanguage = languageItems.filter(languageItem => !vueItems.some(vueItem => languageItem.path === vueItem.path || languageItem.path.startsWith(vueItem.path + '.'))).map(languageItem => _extends({}, languageItem, {
-      language
-    }));
-    missingKeys.push(...missingKeysInLanguage);
-    unusedKeys.push(...unusedKeysInLanguage);
+
+    if (detect.includes(DetectionType.Missing)) {
+      const missingKeysInLanguage = vueItems.filter(vueItem => !mightBeDynamic(vueItem)).filter(vueItem => !languageItems.some(languageItem => vueItem.path === languageItem.path)).map(vueItem => _extends({}, stripBounding(vueItem), {
+        language
+      }));
+      missingKeys.push(...missingKeysInLanguage);
+    }
+
+    if (detect.includes(DetectionType.Unused)) {
+      const unusedKeysInLanguage = languageItems.filter(languageItem => !vueItems.some(vueItem => languageItem.path === vueItem.path || languageItem.path.startsWith(vueItem.path + '.'))).map(languageItem => _extends({}, languageItem, {
+        language
+      }));
+      unusedKeys.push(...unusedKeysInLanguage);
+    }
   });
   return {
     missingKeys,
@@ -323,16 +343,25 @@ async function createI18NReport(options) {
     exclude = [],
     ci,
     separator,
-    noEmptyTranslation = ''
+    noEmptyTranslation = '',
+    missingTranslationString = '',
+    detect = [DetectionType.Missing, DetectionType.Unused, DetectionType.Dynamic]
   } = options;
   if (!vueFilesGlob) throw new Error('Required configuration vueFiles is missing.');
   if (!languageFilesGlob) throw new Error('Required configuration languageFiles is missing.');
+  let issuesToDetect = Array.isArray(detect) ? detect : [detect];
+  const invalidDetectOptions = issuesToDetect.filter(item => !Object.values(DetectionType).includes(item));
+
+  if (invalidDetectOptions.length) {
+    throw new Error(`Invalid 'detect' value(s): ${invalidDetectOptions}`);
+  }
+
   const dot = typeof separator === 'string' ? new Dot(separator) : Dot;
   const vueFiles = readVueFiles(path.resolve(process.cwd(), vueFilesGlob));
   const languageFiles = readLanguageFiles(path.resolve(process.cwd(), languageFilesGlob));
   const I18NItems = extractI18NItemsFromVueFiles(vueFiles);
   const I18NLanguage = extractI18NLanguageFromLanguageFiles(languageFiles, dot);
-  const report = extractI18NReport(I18NItems, I18NLanguage);
+  const report = extractI18NReport(I18NItems, I18NLanguage, issuesToDetect);
   report.unusedKeys = report.unusedKeys.filter(key => !exclude.filter(excluded => key.path.startsWith(excluded)).length);
   if (report.missingKeys.length) console.info('\nMissing Keys'), console.table(report.missingKeys);
   if (report.unusedKeys.length) console.info('\nUnused Keys'), console.table(report.unusedKeys);
@@ -349,7 +378,7 @@ async function createI18NReport(options) {
   }
 
   if (add && report.missingKeys.length) {
-    writeMissingToLanguageFiles(languageFiles, report.missingKeys, dot, noEmptyTranslation);
+    writeMissingToLanguageFiles(languageFiles, report.missingKeys, dot, noEmptyTranslation, missingTranslationString);
     console.info('\nThe missing keys have been added to your language files.');
   }
 
@@ -373,5 +402,5 @@ process.on('unhandledRejection', err => {
   process.exit(1);
 });
 
-export { createI18NReport, extractI18NItemsFromVueFiles, extractI18NLanguageFromLanguageFiles, extractI18NReport, initCommand, parseVueFiles, parselanguageFiles, readLanguageFiles, readVueFiles, removeUnusedFromLanguageFiles, resolveConfig, writeMissingToLanguageFiles, writeReportToFile };
+export { DetectionType, createI18NReport, extractI18NItemsFromVueFiles, extractI18NLanguageFromLanguageFiles, extractI18NReport, initCommand, parseVueFiles, parselanguageFiles, readLanguageFiles, readVueFiles, removeUnusedFromLanguageFiles, resolveConfig, writeMissingToLanguageFiles, writeReportToFile };
 //# sourceMappingURL=vue-i18n-extract.modern.mjs.map