bump version

(feature) Use AST-based approach to translate pipe parsing. Also enables parsing translate pipes from any position in a pipe chain. Fixes #111, Fixes #154. (Thanks @TekSiDoT)

.gitignore

@@ -8,6 +8,8 @@ npm-debug.log*
 
 # Compiled files
 dist
+src/**/*.js
+tests/**/*.js
 
 # Extracted strings
 strings.json

README.md

@@ -2,13 +2,11 @@ If this tool saves you time, please consider making a donation towards the conti
 
 [![Donate](images/donate-badge.png)](https://donate.biesbjerg.com)
 
-# Usage
-
-## ngx-translate-extract
+# ngx-translate-extract
 Extract translatable (ngx-translate) strings and save as a JSON or Gettext pot file.
 Merges with existing strings if the output file already exists.
 
-### Usage
+## Install
 Install the package in your project:
 
 `npm install @biesbjerg/ngx-translate-extract --save-dev`
@@ -23,7 +21,7 @@ Add a script to your project's `package.json`:
 ```
 You can now run `npm run extract-i18n` and it will extract strings from your project.
 
-### Examples
+## Usage
 
 **Extract from dir and save to file**
 
@@ -36,14 +34,8 @@ You can now run `npm run extract-i18n` and it will extract strings from your pro
 
 **Extract and save to multiple files using path expansion**
 
-_Note: This method does not work on Windows!_
-
 `ngx-translate-extract --input ./src --output ./src/i18n/{da,en}.json`
 
-On Windows you must specify each output destination individually:
-
-`ngx-translate-extract --input ./src --output ./src/i18n/da.json ./src/i18n/en.json`
-
 ### JSON indentation
 Tabs are used by default for indentation when saving extracted strings in json formats:
 
@@ -51,8 +43,8 @@ If you want to use spaces instead, you can do the following:
 
 `ngx-translate-extract --input ./src --output ./src/i18n/en.json --format-indentation '  '`
 
-## Mark strings for extraction using a marker function
-If, for some reason, you want to extract strings not passed directly to `TranslateService`'s `get()` or `instant()` methods, you can wrap them in a marker function to let `ngx-translate-extract` know you want to extract them.
+### Marker function
+If you want to extract strings that are not passed directly to `TranslateService`'s `get()`/`instant()`/`stream()` methods, you can wrap them in a marker function to let `ngx-translate-extract` know you want to extract them.
 
 Install marker function:
 `npm install @biesbjerg/ngx-translate-extract-marker`
@@ -63,10 +55,6 @@ import { marker } from '@biesbjerg/ngx-translate-extract-marker';
 marker('Extract me');
 ```
 
-Add the `marker` argument when running the extract script:
-
-`ngx-translate-extract ... -m extract`
-
 You can alias the marker function if needed:
 
 ```ts
@@ -75,37 +63,40 @@ import { marker as _ } from '@biesbjerg/ngx-translate-extract-marker';
 _('Extract me');
 ```
 
-`ngx-translate-extract ... -m _`
+_Note: `ngx-translate-extract` will automatically detect the import name_
 
-## Commandline arguments
-```shell
+### Commandline arguments
+```
 Usage:
 ngx-translate-extract [options]
 
-Options:
-  --version, -v               Show version number                      [boolean]
-  --help, -h                  Show help                                [boolean]
-  --input, -i                 Paths you would like to extract strings from. You
-                              can use path expansion, glob patterns and multiple
-                              paths
-                      [array] [default: current working path]
-  --patterns, -p              Extract strings from the following file patterns
-                                    [array] [default: ["/**/*.html","/**/*.ts"]]
-  --output, -o                Paths where you would like to save extracted
-                              strings. You can use path expansion, glob patterns
-                              and multiple paths              [array] [required]
-  --format, -f                Output format
-          [string] [choices: "json", "namespaced-json", "pot"] [default: "json"]
-  --format-indentation, --fi  Output format indentation   [string] [default: "	"]
-  --replace, -r               Replace the contents of output file if it exists
-                              (Merges by default)     [boolean] [default: false]
-  --sort, -s                  Sort strings in alphabetical order when saving
-                                                      [boolean] [default: false]
-  --clean, -c                 Remove obsolete strings when merging
-                                                      [boolean] [default: false]
-  --key-as-default-value, -k   Use key as default value for translations
-                                                      [boolean] [default: false]
-  --null-as-default-value, -n  Use null as default value for translations
-                                                      [boolean] [default: false]
+Output
+  --format, -f                Format    [string] [choices: "json", "namespaced-json", "pot"] [default: "json"]
+  --format-indentation, --fi  Format indentation (JSON/Namedspaced JSON)                [string] [default: "	"]
+  --sort, -s                  Sort strings in alphabetical order                                     [boolean]
+  --clean, -c                 Remove obsolete strings after merge                                    [boolean]
+  --replace, -r               Replace the contents of output file if it exists (Merges by default)   [boolean]
 
-Arguments key-as-default-value and null-as-default-value are mutually exclusive
+Extracted key value (defaults to empty string)
+  --key-as-default-value, -k     Use key as default value                                            [boolean]
+  --null-as-default-value, -n    Use null as default value                                           [boolean]
+  --string-as-default-value, -d  Use string as default value                                          [string]
+
+Options:
+  --version, -v  Show version number                                                                 [boolean]
+  --help, -h     Show help                                                                           [boolean]
+  --input, -i    Paths you would like to extract strings from. You can use path expansion, glob patterns and
+                 multiple paths        [array] [required] [default: ["/Users/kim/apps/ngx-translate-extract"]]
+  --output, -o   Paths where you would like to save extracted strings. You can use path expansion, glob
+                 patterns and multiple paths                                                [array] [required]
+
+Examples:
+  ngx-translate-extract -i ./src-a/ -i ./src-b/ -o strings.json           Extract (ts, html) from multiple paths
+  ngx-translate-extract -i './{src-a,src-b}/' -o strings.json             Extract (ts, html) from multiple paths using brace
+                                                           expansion
+  ngx-translate-extract -i ./src/ -o ./i18n/da.json -o ./i18n/en.json     Extract (ts, html) and save to da.json and en.json
+  ngx-translate-extract -i ./src/ -o './i18n/{en,da}.json'                Extract (ts, html) and save to da.json and en.json
+                                                           using brace expansion
+  ngx-translate-extract -i './src/**/*.{ts,tsx,html}' -o strings.json     Extract from ts, tsx and html
+  ngx-translate-extract -i './src/**/!(*.spec).{ts,html}' -o              Extract from ts, html, excluding files with ".spec"
+  strings.json

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@biesbjerg/ngx-translate-extract",
-  "version": "4.1.0",
+  "version": "6.0.0",
   "description": "Extract strings from projects using ngx-translate",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -14,10 +14,27 @@
   "scripts": {
     "build": "npm run clean && tsc",
     "watch": "npm run clean && tsc --watch",
-    "clean": "rm -rf ./dist",
+    "clean": "rimraf ./dist",
     "lint": "tslint --force './src/**/*.ts'",
     "test": "mocha -r ts-node/register tests/**/*.spec.ts"
   },
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged && npm test"
+    }
+  },
+  "prettier": {
+    "trailingComma": "none",
+    "printWidth": 145,
+    "useTabs": true,
+    "singleQuote": true
+  },
+  "lint-staged": {
+    "{src,tests}/**/*.{ts}": [
+      "tslint --project tsconfig.json -c tslint.commit.json --fix",
+      "prettier --write"
+    ]
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/biesbjerg/ngx-translate-extract.git"
@@ -40,38 +57,43 @@
   },
   "homepage": "https://github.com/biesbjerg/ngx-translate-extract",
   "engines": {
-    "node": ">=8"
+    "node": ">=12"
   },
   "config": {},
   "devDependencies": {
-    "@types/chai": "^4.2.2",
-    "@types/flat": "^0.0.28",
+    "@types/braces": "^3.0.0",
+    "@types/chai": "^4.2.11",
+    "@types/flat": "^5.0.0",
     "@types/glob": "^7.1.1",
-    "@types/mkdirp": "^0.5.2",
-    "@types/mocha": "^5.2.7",
-    "@types/node": "^12.7.5",
-    "@types/yargs": "^13.0.2",
+    "@types/mkdirp": "^1.0.0",
+    "@types/mocha": "^7.0.2",
+    "@types/node": "^12.12.30",
+    "@types/yargs": "^15.0.4",
+    "braces": "^3.0.2",
     "chai": "^4.2.0",
-    "mocha": "^6.2.0",
-    "ts-node": "^8.4.1",
-    "tslint": "^5.20.0",
-    "tslint-eslint-rules": "^5.4.0"
+    "husky": "^4.2.3",
+    "lint-staged": "^10.0.8",
+    "mocha": "^7.1.1",
+    "prettier": "^1.19.1",
+    "ts-node": "^8.7.0",
+    "tslint": "^6.1.0",
+    "tslint-config-prettier": "^1.18.0",
+    "tslint-eslint-rules": "^5.4.0",
+    "tslint-etc": "^1.10.1",
+    "rimraf": "^3.0.2"
   },
-  "bundledDependencies": [
-    "flat"
-  ],
   "dependencies": {
-    "@angular/compiler": "^8.2.6",
-    "@phenomnomnominal/tsquery": "^3.0.0",
-    "boxen": "^4.1.0",
+    "@angular/compiler": "^9.0.7",
+    "@phenomnomnominal/tsquery": "^4.0.0",
+    "boxen": "^4.2.0",
     "colorette": "^1.1.0",
-    "flat": "github:lenchvolodymyr/flat#ffe77ef",
-    "gettext-parser": "^4.0.2",
-    "glob": "^7.1.4",
-    "mkdirp": "^0.5.1",
+    "flat": "^5.0.0",
+    "gettext-parser": "^4.0.3",
+    "glob": "^7.1.6",
+    "mkdirp": "^1.0.3",
     "path": "^0.12.7",
-    "terminal-link": "^2.0.0",
-    "typescript": "^3.6.3",
-    "yargs": "^14.0.0"
+    "terminal-link": "^2.1.1",
+    "typescript": "^3.8.3",
+    "yargs": "^15.3.1"
   }
 }

src/cli/cli.ts

@@ -1,4 +1,3 @@
-import * as fs from 'fs';
 import * as yargs from 'yargs';
 
 import { ExtractTask } from './tasks/extract.task';
@@ -11,12 +10,26 @@ import { PostProcessorInterface } from '../post-processors/post-processor.interf
 import { SortByKeyPostProcessor } from '../post-processors/sort-by-key.post-processor';
 import { KeyAsDefaultValuePostProcessor } from '../post-processors/key-as-default-value.post-processor';
 import { NullAsDefaultValuePostProcessor } from '../post-processors/null-as-default-value.post-processor';
+import { StringAsDefaultValuePostProcessor } from '../post-processors/string-as-default-value.post-processor';
 import { PurgeObsoleteKeysPostProcessor } from '../post-processors/purge-obsolete-keys.post-processor';
 import { CompilerInterface } from '../compilers/compiler.interface';
 import { CompilerFactory } from '../compilers/compiler.factory';
+import { normalizePaths } from '../utils/fs-helpers';
 import { donateMessage } from '../utils/donate';
 
-export const cli = yargs
+// First parsing pass to be able to access pattern argument for use input/output arguments
+const y = yargs
+	.option('patterns', {
+		alias: 'p',
+		describe: 'Default patterns',
+		type: 'array',
+		default: ['/**/*.html', '/**/*.ts'],
+		hidden: true
+	});
+
+const parsed = y.parse();
+
+export const cli = y
 	.usage('Extract strings from files for translation.\nUsage: $0 [options]')
 	.version(require(__dirname + '/../../package.json').version)
 	.alias('version', 'v')
@@ -25,24 +38,14 @@ export const cli = yargs
 	.option('input', {
 		alias: 'i',
 		describe: 'Paths you would like to extract strings from. You can use path expansion, glob patterns and multiple paths',
-		default: process.env.PWD,
+		default: [process.env.PWD],
 		type: 'array',
-		normalize: true
+		normalize: true,
+		required: true
 	})
-	.check(options => {
-		(options.input as unknown as string[]).forEach((dir: string) => {
-			if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) {
-				throw new Error(`The path you supplied was not found: '${dir}'`);
-			}
-
-		});
-		return true;
-	})
-	.option('patterns', {
-		alias: 'p',
-		describe: 'Extract strings from the following file patterns',
-		type: 'array',
-		default: ['/**/*.html', '/**/*.ts']
+	.coerce('input', (input: string[]) => {
+		const paths = normalizePaths(input, parsed.patterns);
+		return paths;
 	})
 	.option('output', {
 		alias: 'o',
@@ -51,65 +54,75 @@ export const cli = yargs
 		normalize: true,
 		required: true
 	})
+	.coerce('output', (output: string[]) => {
+		const paths = normalizePaths(output, parsed.patterns);
+		return paths;
+	})
 	.option('format', {
 		alias: 'f',
-		describe: 'Output format',
+		describe: 'Format',
 		default: 'json',
 		type: 'string',
 		choices: ['json', 'namespaced-json', 'pot']
 	})
 	.option('format-indentation', {
 		alias: 'fi',
-		describe: 'Output format indentation',
+		describe: 'Format indentation (JSON/Namedspaced JSON)',
 		default: '\t',
 		type: 'string'
 	})
 	.option('replace', {
 		alias: 'r',
 		describe: 'Replace the contents of output file if it exists (Merges by default)',
-		default: false,
 		type: 'boolean'
 	})
 	.option('sort', {
 		alias: 's',
-		describe: 'Sort strings in alphabetical order when saving',
-		default: false,
+		describe: 'Sort strings in alphabetical order',
 		type: 'boolean'
 	})
 	.option('clean', {
 		alias: 'c',
-		describe: 'Remove obsolete strings when merging',
-		default: false,
+		describe: 'Remove obsolete strings after merge',
 		type: 'boolean'
 	})
 	.option('key-as-default-value', {
 		alias: 'k',
-		describe: 'Use key as default value for translations',
-		default: false,
-		type: 'boolean'
+		describe: 'Use key as default value',
+		type: 'boolean',
+		conflicts: ['null-as-default-value', 'string-as-default-value']
 	})
 	.option('null-as-default-value', {
 		alias: 'n',
-		describe: 'Use null as default value for translations',
-		default: false,
-		type: 'boolean'
+		describe: 'Use null as default value',
+		type: 'boolean',
+		conflicts: ['key-as-default-value', 'string-as-default-value']
 	})
+	.option('string-as-default-value', {
+		alias: 'd',
+		describe: 'Use string as default value',
+		type: 'string',
+		conflicts: ['null-as-default-value', 'key-as-default-value']
+	})
+	.group(['format', 'format-indentation', 'sort', 'clean', 'replace'], 'Output')
+	.group(['key-as-default-value', 'null-as-default-value', 'string-as-default-value'], 'Extracted key value (defaults to empty string)')
 	.conflicts('key-as-default-value', 'null-as-default-value')
+	.example(`$0 -i ./src-a/ -i ./src-b/ -o strings.json`, 'Extract (ts, html) from multiple paths')
+	.example(`$0 -i './{src-a,src-b}/' -o strings.json`, 'Extract (ts, html) from multiple paths using brace expansion')
+	.example(`$0 -i ./src/ -o ./i18n/da.json -o ./i18n/en.json`, 'Extract (ts, html) and save to da.json and en.json')
+	.example(`$0 -i ./src/ -o './i18n/{en,da}.json'`, 'Extract (ts, html) and save to da.json and en.json using brace expansion')
+	.example(`$0 -i './src/**/*.{ts,tsx,html}' -o strings.json`, 'Extract from ts, tsx and html')
+	.example(`$0 -i './src/**/!(*.spec).{ts,html}' -o strings.json`, 'Extract from ts, html, excluding files with ".spec" in filename')
+	.wrap(110)
 	.exitProcess(true)
 	.parse(process.argv);
 
-const extractTask = new ExtractTask(cli.input as unknown as string[], cli.output, {
-	replace: cli.replace,
-	patterns: cli.patterns
+const extractTask = new ExtractTask(cli.input, cli.output, {
+	replace: cli.replace
 });
 
 // Parsers
-const parsers: ParserInterface[] = [
-	new PipeParser(),
-	new DirectiveParser(),
-	new ServiceParser(),
-	new MarkerParser()
-];
+const parsers: ParserInterface[] = [new PipeParser(), new DirectiveParser(), new ServiceParser(), new MarkerParser()];
 extractTask.setParsers(parsers);
 
 // Post processors
@@ -121,7 +134,10 @@ if (cli.keyAsDefaultValue) {
 	postProcessors.push(new KeyAsDefaultValuePostProcessor());
 } else if (cli.nullAsDefaultValue) {
 	postProcessors.push(new NullAsDefaultValuePostProcessor());
+} else if (cli.stringAsDefaultValue) {
+	postProcessors.push(new StringAsDefaultValuePostProcessor({ defaultValue: cli.stringAsDefaultValue as string }));
 }
+
 if (cli.sort) {
 	postProcessors.push(new SortByKeyPostProcessor());
 }

src/cli/tasks/extract.task.ts

@@ -12,14 +12,11 @@ import * as mkdirp from 'mkdirp';
 
 export interface ExtractTaskOptionsInterface {
 	replace?: boolean;
-	patterns?: string[];
 }
 
 export class ExtractTask implements TaskInterface {
-
 	protected options: ExtractTaskOptionsInterface = {
-		replace: false,
-		patterns: []
+		replace: false
 	};
 
 	protected parsers: ParserInterface[] = [];
@@ -101,13 +98,13 @@ export class ExtractTask implements TaskInterface {
 	 */
 	protected extract(): TranslationCollection {
 		let collection: TranslationCollection = new TranslationCollection();
-		this.inputs.forEach(dir => {
-			this.readDir(dir, this.options.patterns).forEach(path => {
-				this.out(dim('- %s'), path);
-				const contents: string = fs.readFileSync(path, 'utf-8');
+		this.inputs.forEach(pattern => {
+			this.getFiles(pattern).forEach(filePath => {
+				this.out(dim('- %s'), filePath);
+				const contents: string = fs.readFileSync(filePath, 'utf-8');
 				this.parsers.forEach(parser => {
-					const extracted = parser.extract(contents, path);
-					if (extracted) {
+					const extracted = parser.extract(contents, filePath);
+					if (extracted instanceof TranslationCollection) {
 						collection = collection.union(extracted);
 					}
 				});
@@ -139,14 +136,12 @@ export class ExtractTask implements TaskInterface {
 	}
 
 	/**
-	 * Get all files in dir matching patterns
+	 * Get all files matching pattern
 	 */
-	protected readDir(dir: string, patterns: string[]): string[] {
-		return patterns.reduce((results, pattern) => {
-			return glob.sync(dir + pattern)
-				.filter(path => fs.statSync(path).isFile())
-				.concat(results);
-		}, []);
+	protected getFiles(pattern: string): string[] {
+		return glob
+			.sync(pattern)
+			.filter(filePath => fs.statSync(filePath).isFile());
 	}
 
 	protected out(...args: any[]): void {
@@ -178,5 +173,4 @@ export class ExtractTask implements TaskInterface {
 		this.out(cyan(dim(`- ${this.compiler.constructor.name}`)));
 		this.out();
 	}
-
 }

src/compilers/compiler.factory.ts

@@ -4,14 +4,16 @@ import { NamespacedJsonCompiler } from '../compilers/namespaced-json.compiler';
 import { PoCompiler } from '../compilers/po.compiler';
 
 export class CompilerFactory {
-
 	public static create(format: string, options?: {}): CompilerInterface {
 		switch (format) {
-			case 'pot': return new PoCompiler(options);
-			case 'json': return new JsonCompiler(options);
-			case 'namespaced-json': return new NamespacedJsonCompiler(options);
-			default: throw new Error(`Unknown format: ${format}`);
+			case 'pot':
+				return new PoCompiler(options);
+			case 'json':
+				return new JsonCompiler(options);
+			case 'namespaced-json':
+				return new NamespacedJsonCompiler(options);
+			default:
+				throw new Error(`Unknown format: ${format}`);
 		}
 	}
-
 }

src/compilers/compiler.interface.ts

@@ -1,11 +1,9 @@
 import { TranslationCollection } from '../utils/translation.collection';
 
 export interface CompilerInterface {
-
 	extension: string;
 
 	compile(collection: TranslationCollection): string;
 
 	parse(contents: string): TranslationCollection;
-
 }

src/compilers/json.compiler.ts

@@ -5,7 +5,6 @@ import { stripBOM } from '../utils/utils';
 import { flatten } from 'flat';
 
 export class JsonCompiler implements CompilerInterface {
-
 	public indentation: string = '\t';
 
 	public extension: string = 'json';
@@ -31,5 +30,4 @@ export class JsonCompiler implements CompilerInterface {
 	protected isNamespacedJsonFormat(values: any): boolean {
 		return Object.keys(values).some(key => typeof values[key] === 'object');
 	}
-
 }

src/compilers/namespaced-json.compiler.ts

@@ -5,7 +5,6 @@ import { stripBOM } from '../utils/utils';
 import { flatten, unflatten } from 'flat';
 
 export class NamespacedJsonCompiler implements CompilerInterface {
-
 	public indentation: string = '\t';
 
 	public extension = 'json';
@@ -27,5 +26,4 @@ export class NamespacedJsonCompiler implements CompilerInterface {
 		const values: {} = flatten(JSON.parse(stripBOM(contents)));
 		return new TranslationCollection(values);
 	}
-
 }

src/compilers/po.compiler.ts

@@ -4,7 +4,6 @@ import { TranslationCollection, TranslationType } from '../utils/translation.col
 import * as gettext from 'gettext-parser';
 
 export class PoCompiler implements CompilerInterface {
-
 	public extension: string = 'po';
 
 	/**
@@ -23,13 +22,18 @@ export class PoCompiler implements CompilerInterface {
 				'content-transfer-encoding': '8bit'
 			},
 			translations: {
-				[this.domain]: Object.keys(collection.values).reduce((translations, key) => {
-					translations[key] = {
-						msgid: key,
-						msgstr: collection.get(key)
-					};
-					return translations;
-				}, {} as any)
+				[this.domain]: Object.keys(collection.values).reduce(
+					(translations, key) => {
+						return {
+							...translations,
+							[key]: {
+								msgid: key,
+								msgstr: collection.get(key)
+							}
+						};
+					},
+					{} as any
+				)
 			}
 		};
 
@@ -46,12 +50,16 @@ export class PoCompiler implements CompilerInterface {
 
 		const values = Object.keys(po.translations[this.domain])
 			.filter(key => key.length > 0)
-			.reduce((values, key) => {
-				values[key] = po.translations[this.domain][key].msgstr.pop();
-				return values;
-			}, {} as TranslationType);
+			.reduce(
+				(result, key) => {
+					return {
+						...result,
+						[key]: po.translations[this.domain][key].msgstr.pop()
+					};
+				},
+				{} as TranslationType
+			);
 
 		return new TranslationCollection(values);
 	}
-
 }

src/parsers/directive.parser.ts

@@ -5,17 +5,16 @@ import { isPathAngularComponent, extractComponentInlineTemplate } from '../utils
 import { parseTemplate, TmplAstNode, TmplAstElement, TmplAstTextAttribute } from '@angular/compiler';
 
 export class DirectiveParser implements ParserInterface {
-
-	public extract(template: string, path: string): TranslationCollection {
-		if (path && isPathAngularComponent(path)) {
-			template = extractComponentInlineTemplate(template);
+	public extract(source: string, filePath: string): TranslationCollection | null {
+		if (filePath && isPathAngularComponent(filePath)) {
+			source = extractComponentInlineTemplate(source);
 		}
 
 		let collection: TranslationCollection = new TranslationCollection();
 
-		const nodes: TmplAstNode[] = this.parseTemplate(template, path);
+		const nodes: TmplAstNode[] = this.parseTemplate(source, filePath);
 		this.getTranslatableElements(nodes).forEach(element => {
-			const key = this.getElementTranslateAttrValue(element) || this.getElementContents(element);
+			const key = this.getElementTranslateAttrValue(element) || this.getElementContent(element);
 			collection = collection.add(key);
 		});
 
@@ -36,19 +35,22 @@ export class DirectiveParser implements ParserInterface {
 			return [];
 		}
 
-		// If element has translate attribute all its contents is translatable
+		// If element has translate attribute all its content is translatable
 		// so we don't need to traverse any deeper
 		if (this.isTranslatable(node)) {
 			return [node];
 		}
 
-		return node.children.reduce((result: TmplAstElement[], childNode: TmplAstNode) => {
-			if (this.isElement(childNode)) {
-				const children = this.findChildrenElements(childNode);
-				return result.concat(children);
-			}
-			return result;
-		}, [node]);
+		return node.children.reduce(
+			(result: TmplAstElement[], childNode: TmplAstNode) => {
+				if (this.isElement(childNode)) {
+					const children = this.findChildrenElements(childNode);
+					return result.concat(children);
+				}
+				return result;
+			},
+			[node]
+		);
 	}
 
 	protected parseTemplate(template: string, path: string): TmplAstNode[] {
@@ -56,9 +58,7 @@ export class DirectiveParser implements ParserInterface {
 	}
 
 	protected isElement(node: any): node is TmplAstElement {
-		return node
-			&& node.attributes !== undefined
-			&& node.children !== undefined;
+		return node?.attributes && node?.children;
 	}
 
 	protected isTranslatable(node: TmplAstNode): boolean {
@@ -70,14 +70,18 @@ export class DirectiveParser implements ParserInterface {
 
 	protected getElementTranslateAttrValue(element: TmplAstElement): string {
 		const attr: TmplAstTextAttribute = element.attributes.find(attribute => attribute.name === 'translate');
-		return attr && attr.value || '';
+		return attr?.value ?? '';
 	}
 
-	protected getElementContents(element: TmplAstElement): string {
-		const contents = element.sourceSpan.start.file.content;
+	protected getElementContent(element: TmplAstElement): string {
+		const content = element.sourceSpan.start.file.content;
 		const start = element.startSourceSpan.end.offset;
 		const end = element.endSourceSpan.start.offset;
-		return contents.substring(start, end).trim();
+		const val = content.substring(start, end);
+		return this.cleanKey(val);
 	}
 
+	protected cleanKey(val: string): string {
+		return val.replace(/\r?\n|\r|\t/g, '');
+	}
 }

src/parsers/marker.parser.ts

@@ -4,31 +4,29 @@ import { ParserInterface } from './parser.interface';
 import { TranslationCollection } from '../utils/translation.collection';
 import { getNamedImportAlias, findFunctionCallExpressions, getStringsFromExpression } from '../utils/ast-helpers';
 
-const MARKER_PACKAGE_MODULE_NAME = '@biesbjerg/ngx-translate-extract-marker';
-const MARKER_PACKAGE_IMPORT_NAME = 'marker';
+const MARKER_MODULE_NAME = '@biesbjerg/ngx-translate-extract-marker';
+const MARKER_IMPORT_NAME = 'marker';
 
 export class MarkerParser implements ParserInterface {
+	public extract(source: string, filePath: string): TranslationCollection | null {
+		const sourceFile = tsquery.ast(source, filePath);
 
-	public extract(contents: string, filePath: string): TranslationCollection | null {
-		const sourceFile = tsquery.ast(contents, filePath);
-
-		const markerFnName = getNamedImportAlias(sourceFile, MARKER_PACKAGE_MODULE_NAME, MARKER_PACKAGE_IMPORT_NAME);
-		if (!markerFnName) {
-			return;
+		const markerImportName = getNamedImportAlias(sourceFile, MARKER_MODULE_NAME, MARKER_IMPORT_NAME);
+		if (!markerImportName) {
+			return null;
 		}
 
 		let collection: TranslationCollection = new TranslationCollection();
 
-		const callNodes = findFunctionCallExpressions(sourceFile, markerFnName);
-		callNodes.forEach(callNode => {
-			const [firstArgNode] = callNode.arguments;
-			if (!firstArgNode) {
+		const callExpressions = findFunctionCallExpressions(sourceFile, markerImportName);
+		callExpressions.forEach(callExpression => {
+			const [firstArg] = callExpression.arguments;
+			if (!firstArg) {
 				return;
 			}
-			const strings = getStringsFromExpression(firstArgNode);
+			const strings = getStringsFromExpression(firstArg);
 			collection = collection.addKeys(strings);
 		});
 		return collection;
 	}
-
 }

src/parsers/parser.interface.ts

@@ -1,7 +1,5 @@
 import { TranslationCollection } from '../utils/translation.collection';
 
 export interface ParserInterface {
-
 	extract(source: string, filePath: string): TranslationCollection | null;
-
 }

src/parsers/pipe.parser.ts

@@ -1,27 +1,100 @@
+import { TmplAstNode, parseTemplate, BindingPipe, LiteralPrimitive, Conditional, TmplAstTextAttribute } from '@angular/compiler';
+
 import { ParserInterface } from './parser.interface';
 import { TranslationCollection } from '../utils/translation.collection';
 import { isPathAngularComponent, extractComponentInlineTemplate } from '../utils/utils';
 
+const TRANSLATE_PIPE_NAME = 'translate';
+
 export class PipeParser implements ParserInterface {
-
-	public extract(template: string, path: string): TranslationCollection {
-		if (path && isPathAngularComponent(path)) {
-			template = extractComponentInlineTemplate(template);
+	public extract(source: string, filePath: string): TranslationCollection | null {
+		if (filePath && isPathAngularComponent(filePath)) {
+			source = extractComponentInlineTemplate(source);
 		}
 
-		return this.parseTemplate(template);
-	}
-
-	protected parseTemplate(template: string): TranslationCollection {
 		let collection: TranslationCollection = new TranslationCollection();
-
-		const regExp: RegExp = /(['"`])((?:(?!\1).|\\\1)+)\1\s*\|\s*translate/g;
-		let matches: RegExpExecArray;
-		while (matches = regExp.exec(template)) {
-			collection = collection.add(matches[2].split('\\\'').join('\''));
-		}
-
+		const nodes: TmplAstNode[] = this.parseTemplate(source, filePath);
+		const pipes: BindingPipe[] = nodes.map(node => this.findPipesInNode(node)).flat();
+		pipes.forEach(pipe => {
+			this.parseTranslationKeysFromPipe(pipe).forEach((key: string) => {
+				collection = collection.add(key);
+			});
+		});
 		return collection;
 	}
 
+	protected findPipesInNode(node: any): BindingPipe[] {
+		let ret: BindingPipe[] = [];
+
+		if (node?.children) {
+			ret = node.children.reduce(
+				(result: BindingPipe[], childNode: TmplAstNode) => {
+					const children = this.findPipesInNode(childNode);
+					return result.concat(children);
+				},
+				[ret]
+			);
+		}
+
+		if (node?.value?.ast?.expressions) {
+			const translateables = node.value.ast.expressions.filter((exp: any) => this.expressionIsOrHasBindingPipe(exp));
+			ret.push(...translateables);
+		}
+
+		if (node?.attributes) {
+			const translateableAttributes = node.attributes.filter((attr: TmplAstTextAttribute) => {
+				return attr.name === TRANSLATE_PIPE_NAME;
+			});
+			ret = [...ret, ...translateableAttributes];
+		}
+
+		if (node?.inputs) {
+			node.inputs.forEach((input: any) => {
+				// <element [attrib]="'identifier' | translate">
+				if (input?.value?.ast && this.expressionIsOrHasBindingPipe(input.value.ast)) {
+					ret.push(input.value.ast);
+				}
+
+				// <element attrib="{{'identifier' | translate}}>"
+				if (input?.value?.ast?.expressions) {
+					input.value.ast.expressions.forEach((exp: BindingPipe) => {
+						if (this.expressionIsOrHasBindingPipe(exp)) {
+							ret.push(exp);
+						}
+					});
+				}
+			});
+		}
+
+		return ret;
+	}
+
+	protected parseTranslationKeysFromPipe(pipeContent: BindingPipe | LiteralPrimitive | Conditional): string[] {
+		const ret: string[] = [];
+		if (pipeContent instanceof LiteralPrimitive) {
+			ret.push(pipeContent.value);
+		} else if (pipeContent instanceof Conditional) {
+			const trueExp: LiteralPrimitive | Conditional = pipeContent.trueExp as any;
+			ret.push(...this.parseTranslationKeysFromPipe(trueExp));
+			const falseExp: LiteralPrimitive | Conditional = pipeContent.falseExp as any;
+			ret.push(...this.parseTranslationKeysFromPipe(falseExp));
+		} else if (pipeContent instanceof BindingPipe) {
+			ret.push(...this.parseTranslationKeysFromPipe(pipeContent.exp as any));
+		}
+		return ret;
+	}
+
+	protected expressionIsOrHasBindingPipe(exp: any): boolean {
+		if (exp.name && exp.name === TRANSLATE_PIPE_NAME) {
+			return true;
+		}
+		if (exp.exp && exp.exp instanceof BindingPipe) {
+			return this.expressionIsOrHasBindingPipe(exp.exp);
+		}
+		return false;
+	}
+
+	protected parseTemplate(template: string, path: string): TmplAstNode[] {
+		return parseTemplate(template, path).nodes;
+	}
 }

src/parsers/service.parser.ts

@@ -1,41 +1,56 @@
+import { ClassDeclaration, CallExpression } from 'typescript';
 import { tsquery } from '@phenomnomnominal/tsquery';
 
 import { ParserInterface } from './parser.interface';
 import { TranslationCollection } from '../utils/translation.collection';
-import { findClasses, findClassPropertyByType, findMethodCallExpressions, getStringsFromExpression } from '../utils/ast-helpers';
+import { findClassDeclarations, findClassPropertyByType, findPropertyCallExpressions, findMethodCallExpressions, getStringsFromExpression, findMethodParameterByType, findConstructorDeclaration } from '../utils/ast-helpers';
 
 const TRANSLATE_SERVICE_TYPE_REFERENCE = 'TranslateService';
 const TRANSLATE_SERVICE_METHOD_NAMES = ['get', 'instant', 'stream'];
 
 export class ServiceParser implements ParserInterface {
-
 	public extract(source: string, filePath: string): TranslationCollection | null {
 		const sourceFile = tsquery.ast(source, filePath);
 
-		const classNodes = findClasses(sourceFile);
-		if (!classNodes) {
-			return;
+		const classDeclarations = findClassDeclarations(sourceFile);
+		if (!classDeclarations) {
+			return null;
 		}
 
 		let collection: TranslationCollection = new TranslationCollection();
 
-		classNodes.forEach(classNode => {
-			const propName: string = findClassPropertyByType(classNode, TRANSLATE_SERVICE_TYPE_REFERENCE);
-			if (!propName) {
-				return;
-			}
+		classDeclarations.forEach(classDeclaration => {
+			const callExpressions = [
+				...this.findConstructorParamCallExpressions(classDeclaration),
+				...this.findPropertyCallExpressions(classDeclaration)
+			];
 
-			const callNodes = findMethodCallExpressions(classNode, propName, TRANSLATE_SERVICE_METHOD_NAMES);
-			callNodes.forEach(callNode => {
-				const [firstArgNode] = callNode.arguments;
-				if (!firstArgNode) {
+			callExpressions.forEach(callExpression => {
+				const [firstArg] = callExpression.arguments;
+				if (!firstArg) {
 					return;
 				}
-				const strings = getStringsFromExpression(firstArgNode);
+				const strings = getStringsFromExpression(firstArg);
 				collection = collection.addKeys(strings);
 			});
 		});
 		return collection;
 	}
 
+	protected findConstructorParamCallExpressions(classDeclaration: ClassDeclaration): CallExpression[] {
+		const constructorDeclaration = findConstructorDeclaration(classDeclaration);
+		if (!constructorDeclaration) {
+			return [];
+		}
+		const paramName = findMethodParameterByType(constructorDeclaration, TRANSLATE_SERVICE_TYPE_REFERENCE);
+		return findMethodCallExpressions(constructorDeclaration, paramName, TRANSLATE_SERVICE_METHOD_NAMES);
+	}
+
+	protected findPropertyCallExpressions(classDeclaration: ClassDeclaration): CallExpression[] {
+		const propName: string = findClassPropertyByType(classDeclaration, TRANSLATE_SERVICE_TYPE_REFERENCE);
+		if (!propName) {
+			return [];
+		}
+		return findPropertyCallExpressions(classDeclaration, propName, TRANSLATE_SERVICE_METHOD_NAMES);
+	}
 }

src/post-processors/key-as-default-value.post-processor.ts

@@ -2,11 +2,9 @@ import { TranslationCollection } from '../utils/translation.collection';
 import { PostProcessorInterface } from './post-processor.interface';
 
 export class KeyAsDefaultValuePostProcessor implements PostProcessorInterface {
-
 	public name: string = 'KeyAsDefaultValue';
 
 	public process(draft: TranslationCollection, extracted: TranslationCollection, existing: TranslationCollection): TranslationCollection {
-		return draft.map((key, val) => val === '' ? key : val);
+		return draft.map((key, val) => (val === '' ? key : val));
 	}
-
 }

src/post-processors/null-as-default-value.post-processor.ts

@@ -2,11 +2,9 @@ import { TranslationCollection } from '../utils/translation.collection';
 import { PostProcessorInterface } from './post-processor.interface';
 
 export class NullAsDefaultValuePostProcessor implements PostProcessorInterface {
-
 	public name: string = 'NullAsDefaultValue';
 
 	public process(draft: TranslationCollection, extracted: TranslationCollection, existing: TranslationCollection): TranslationCollection {
-		return draft.map((key, val) => existing.get(key) === undefined ? null : val);
+		return draft.map((key, val) => (existing.get(key) === undefined ? null : val));
 	}
-
 }

src/post-processors/post-processor.interface.ts

@@ -1,9 +1,7 @@
 import { TranslationCollection } from '../utils/translation.collection';
 
 export interface PostProcessorInterface {
-
 	name: string;
 
 	process(draft: TranslationCollection, extracted: TranslationCollection, existing: TranslationCollection): TranslationCollection;
-
 }

src/post-processors/purge-obsolete-keys.post-processor.ts

@@ -2,11 +2,9 @@ import { TranslationCollection } from '../utils/translation.collection';
 import { PostProcessorInterface } from './post-processor.interface';
 
 export class PurgeObsoleteKeysPostProcessor implements PostProcessorInterface {
-
 	public name: string = 'PurgeObsoleteKeys';
 
 	public process(draft: TranslationCollection, extracted: TranslationCollection, existing: TranslationCollection): TranslationCollection {
 		return draft.intersect(extracted);
 	}
-
 }

src/post-processors/sort-by-key.post-processor.ts

@@ -2,11 +2,9 @@ import { TranslationCollection } from '../utils/translation.collection';
 import { PostProcessorInterface } from './post-processor.interface';
 
 export class SortByKeyPostProcessor implements PostProcessorInterface {
-
 	public name: string = 'SortByKey';
 
 	public process(draft: TranslationCollection, extracted: TranslationCollection, existing: TranslationCollection): TranslationCollection {
 		return draft.sort();
 	}
-
 }

src/post-processors/string-as-default-value.post-processor.ts

@@ -0,0 +1,16 @@
+import { TranslationCollection } from '../utils/translation.collection';
+import { PostProcessorInterface } from './post-processor.interface';
+
+interface Options {
+	defaultValue: string;
+}
+
+export class StringAsDefaultValuePostProcessor implements PostProcessorInterface {
+	public name: string = 'StringAsDefaultValue';
+
+	public constructor(protected options: Options) {}
+
+	public process(draft: TranslationCollection, extracted: TranslationCollection, existing: TranslationCollection): TranslationCollection {
+		return draft.map((key, val) => (existing.get(key) === undefined ? this.options.defaultValue : val));
+	}
+}

src/utils/ast-helpers.ts

@@ -1,15 +1,16 @@
 import { tsquery } from '@phenomnomnominal/tsquery';
 import {
+	SyntaxKind,
 	Node,
 	NamedImports,
 	Identifier,
 	ClassDeclaration,
-	CallExpression,
+	ConstructorDeclaration,
 	isStringLiteralLike,
 	isArrayLiteralExpression,
+	CallExpression,
 	Expression,
 	isBinaryExpression,
-	SyntaxKind,
 	isConditionalExpression,
 	PropertyAccessExpression
 } from 'typescript';
@@ -22,7 +23,7 @@ export function getNamedImports(node: Node, moduleName: string): NamedImports[]
 export function getNamedImportAlias(node: Node, moduleName: string, importName: string): string | null {
 	const [namedImportNode] = getNamedImports(node, moduleName);
 	if (!namedImportNode) {
-		return;
+		return null;
 	}
 
 	const query = `ImportSpecifier:has(Identifier[name="${importName}"]) > Identifier`;
@@ -36,7 +37,7 @@ export function getNamedImportAlias(node: Node, moduleName: string, importName:
 	return null;
 }
 
-export function findClasses(node: Node): ClassDeclaration[] {
+export function findClassDeclarations(node: Node): ClassDeclaration[] {
 	const query = 'ClassDeclaration';
 	return tsquery<ClassDeclaration>(node, query);
 }
@@ -45,6 +46,30 @@ export function findClassPropertyByType(node: ClassDeclaration, type: string): s
 	return findClassPropertyConstructorParameterByType(node, type) || findClassPropertyDeclarationByType(node, type);
 }
 
+export function findConstructorDeclaration(node: ClassDeclaration): ConstructorDeclaration {
+	const query = `Constructor`;
+	const [result] = tsquery<ConstructorDeclaration>(node, query);
+	return result;
+}
+
+export function findMethodParameterByType(node: Node, type: string): string | null {
+	const query = `Parameter:has(TypeReference > Identifier[name="${type}"]) > Identifier`;
+	const [result] = tsquery<Identifier>(node, query);
+	if (result) {
+		return result.text;
+	}
+	return null;
+}
+
+export function findMethodCallExpressions(node: Node, propName: string, fnName: string | string[]): CallExpression[] {
+	if (Array.isArray(fnName)) {
+		fnName = fnName.join('|');
+	}
+	const query = `CallExpression > PropertyAccessExpression:has(Identifier[name=/^(${fnName})$/]):has(PropertyAccessExpression:has(Identifier[name="${propName}"]):not(:has(ThisKeyword)))`;
+	const nodes = tsquery<PropertyAccessExpression>(node, query).map(n => n.parent as CallExpression);
+	return nodes;
+}
+
 export function findClassPropertyConstructorParameterByType(node: ClassDeclaration, type: string): string | null {
 	const query = `Constructor Parameter:has(TypeReference > Identifier[name="${type}"]):has(PublicKeyword,ProtectedKeyword,PrivateKeyword) > Identifier`;
 	const [result] = tsquery<Identifier>(node, query);
@@ -72,12 +97,12 @@ export function findFunctionCallExpressions(node: Node, fnName: string | string[
 	return nodes;
 }
 
-export function findMethodCallExpressions(node: Node, prop: string, fnName: string | string[]): CallExpression[] {
+export function findPropertyCallExpressions(node: Node, prop: string, fnName: string | string[]): CallExpression[] {
 	if (Array.isArray(fnName)) {
 		fnName = fnName.join('|');
 	}
 	const query = `CallExpression > PropertyAccessExpression:has(Identifier[name=/^(${fnName})$/]):has(PropertyAccessExpression:has(Identifier[name="${prop}"]):has(ThisKeyword))`;
-	let nodes = tsquery<PropertyAccessExpression>(node, query).map(node => node.parent as CallExpression);
+	const nodes = tsquery<PropertyAccessExpression>(node, query).map(n => n.parent as CallExpression);
 	return nodes;
 }
 
@@ -88,17 +113,14 @@ export function getStringsFromExpression(expression: Expression): string[] {
 
 	if (isArrayLiteralExpression(expression)) {
 		return expression.elements.reduce((result: string[], element: Expression) => {
-			const strings = this.getStringsFromExpression(element);
-			return [
-				...result,
-				...strings
-			];
+			const strings = getStringsFromExpression(element);
+			return [...result, ...strings];
 		}, []);
 	}
 
 	if (isBinaryExpression(expression)) {
-		const [left] = this.getStringsFromExpression(expression.left);
-		const [right] = this.getStringsFromExpression(expression.right);
+		const [left] = getStringsFromExpression(expression.left);
+		const [right] = getStringsFromExpression(expression.right);
 
 		if (expression.operatorToken.kind === SyntaxKind.PlusToken) {
 			if (typeof left === 'string' && typeof right === 'string') {
@@ -119,8 +141,8 @@ export function getStringsFromExpression(expression: Expression): string[] {
 	}
 
 	if (isConditionalExpression(expression)) {
-		const [whenTrue] = this.getStringsFromExpression(expression.whenTrue);
-		const [whenFalse] = this.getStringsFromExpression(expression.whenFalse);
+		const [whenTrue] = getStringsFromExpression(expression.whenTrue);
+		const [whenFalse] = getStringsFromExpression(expression.whenFalse);
 
 		const result = [];
 		if (typeof whenTrue === 'string') {

src/utils/fs-helpers.ts

@@ -0,0 +1,32 @@
+import * as os from 'os';
+import * as fs from 'fs';
+import * as braces from 'braces';
+
+declare module 'braces' {
+	interface Options {
+		keepEscaping?: boolean; // Workaround for option not present in @types/braces 3.0.0
+	}
+}
+
+export function normalizeHomeDir(path: string): string {
+	if (path.substring(0, 1) === '~') {
+		return `${os.homedir()}/${path.substring(1)}`;
+	}
+	return path;
+}
+
+export function expandPattern(pattern: string): string[] {
+	return braces(pattern, { expand: true, keepEscaping: true });
+}
+
+export function normalizePaths(patterns: string[], defaultPatterns: string[] = []): string[] {
+	return patterns.map(pattern =>
+		expandPattern(pattern).map(path => {
+			path = normalizeHomeDir(path);
+			if (fs.existsSync(path) && fs.statSync(path).isDirectory()) {
+				return defaultPatterns.map(defaultPattern => path + defaultPattern);
+			}
+			return path;
+		}).flat()
+	).flat();
+}

src/utils/translation.collection.ts

@@ -3,7 +3,6 @@ export interface TranslationType {
 }
 
 export class TranslationCollection {
-
 	public values: TranslationType = {};
 
 	public constructor(values: TranslationType = {}) {
@@ -15,10 +14,12 @@ export class TranslationCollection {
 	}
 
 	public addKeys(keys: string[]): TranslationCollection {
-		const values = keys.reduce((results, key) => {
-			results[key] = '';
-			return results;
-		}, {} as TranslationType);
+		const values = keys.reduce(
+			(results, key) => {
+				return { ...results, [key]: '' };
+			},
+			{} as TranslationType
+		);
 		return new TranslationCollection({ ...this.values, ...values });
 	}
 
@@ -32,8 +33,8 @@ export class TranslationCollection {
 	}
 
 	public filter(callback: (key?: string, val?: string) => boolean): TranslationCollection {
-		let values: TranslationType = {};
-		this.forEach((key: string, val: string) => {
+		const values: TranslationType = {};
+		this.forEach((key, val) => {
 			if (callback.call(this, key, val)) {
 				values[key] = val;
 			}
@@ -42,8 +43,8 @@ export class TranslationCollection {
 	}
 
 	public map(callback: (key?: string, val?: string) => string): TranslationCollection {
-		let values: TranslationType = {};
-		this.forEach((key: string, val: string) => {
+		const values: TranslationType = {};
+		this.forEach((key, val) => {
 			values[key] = callback.call(this, key, val);
 		});
 		return new TranslationCollection(values);
@@ -54,11 +55,10 @@ export class TranslationCollection {
 	}
 
 	public intersect(collection: TranslationCollection): TranslationCollection {
-		let values: TranslationType = {};
-		this.filter(key => collection.has(key))
-			.forEach((key: string, val: string) => {
-				values[key] = val;
-			});
+		const values: TranslationType = {};
+		this.filter(key => collection.has(key)).forEach((key, val) => {
+			values[key] = val;
+		});
 
 		return new TranslationCollection(values);
 	}
@@ -84,10 +84,12 @@ export class TranslationCollection {
 	}
 
 	public sort(compareFn?: (a: string, b: string) => number): TranslationCollection {
-		let values: TranslationType = {};
-		this.keys().sort(compareFn).forEach((key) => {
-			values[key] = this.get(key);
-		});
+		const values: TranslationType = {};
+		this.keys()
+			.sort(compareFn)
+			.forEach(key => {
+				values[key] = this.get(key);
+			});
 
 		return new TranslationCollection(values);
 	}

src/utils/utils.ts

@@ -2,7 +2,7 @@
  * Assumes file is an Angular component if type is javascript/typescript
  */
 export function isPathAngularComponent(path: string): boolean {
-	return (/\.ts|js$/i).test(path);
+	return /\.ts|js$/i.test(path);
 }
 
 /**

tests/app/login.html

@@ -0,0 +1 @@
+{{ 'SOURCES.' + source.name + '.NAME_PLURAL' | translate }}

tests/compilers/namespaced-json.compiler.spec.ts

@@ -4,7 +4,6 @@ import { TranslationCollection } from '../../src/utils/translation.collection';
 import { NamespacedJsonCompiler } from '../../src/compilers/namespaced-json.compiler';
 
 describe('NamespacedJsonCompiler', () => {
-
 	let compiler: NamespacedJsonCompiler;
 
 	beforeEach(() => {
@@ -23,7 +22,10 @@ describe('NamespacedJsonCompiler', () => {
 			}
 		`;
 		const collection: TranslationCollection = compiler.parse(contents);
-		expect(collection.values).to.deep.equal({'NAMESPACE.KEY.FIRST_KEY': '', 'NAMESPACE.KEY.SECOND_KEY': 'VALUE' });
+		expect(collection.values).to.deep.equal({
+			'NAMESPACE.KEY.FIRST_KEY': '',
+			'NAMESPACE.KEY.SECOND_KEY': 'VALUE'
+		});
 	});
 
 	it('should unflatten keys on compile', () => {
@@ -59,11 +61,10 @@ describe('NamespacedJsonCompiler', () => {
 
 	it('should not reorder keys when compiled', () => {
 		const collection = new TranslationCollection({
-			'BROWSE': '',
-			'LOGIN': ''
+			BROWSE: '',
+			LOGIN: ''
 		});
 		const result: string = compiler.compile(collection);
 		expect(result).to.equal('{\n\t"BROWSE": "",\n\t"LOGIN": ""\n}');
 	});
-
 });

tests/parsers/directive.parser.spec.ts

@@ -3,7 +3,6 @@ import { expect } from 'chai';
 import { DirectiveParser } from '../../src/parsers/directive.parser';
 
 describe('DirectiveParser', () => {
-
 	const templateFilename: string = 'test.template.html';
 	const componentFilename: string = 'test.component.ts';
 
@@ -87,4 +86,31 @@ describe('DirectiveParser', () => {
 		expect(keys).to.deep.equal([]);
 	});
 
+	it('should extract contents without line breaks', () => {
+		const contents = `
+			<p translate>
+				Please leave a message for your client letting them know why you 
+				rejected the field and what they need to do to fix it.
+			</p>
+		`;
+		const keys = parser.extract(contents, templateFilename).keys();
+		expect(keys).to.deep.equal(['Please leave a message for your client letting them know why you rejected the field and what they need to do to fix it.']);
+	});
+
+	it('should extract contents without indent spaces', () => {
+		const contents = `
+			<div *ngIf="!isLoading && studentsToGrid && studentsToGrid.length == 0" class="no-students" mt-rtl translate>There 
+				are currently no students in this class. The good news is, adding students is really easy! Just use the options 
+				at the top.
+			</div>
+		`;
+		const keys = parser.extract(contents, templateFilename).keys();
+		expect(keys).to.deep.equal(['There are currently no students in this class. The good news is, adding students is really easy! Just use the options at the top.']);
+	});
+
+	it('should extract contents without indent spaces', () => {
+		const contents = `<button mat-button (click)="search()" translate>client.search.searchBtn</button>`;
+		const keys = parser.extract(contents, templateFilename).keys();
+		expect(keys).to.deep.equal(['client.search.searchBtn']);
+	});
 });

tests/parsers/marker.parser.spec.ts

@@ -3,7 +3,6 @@ import { expect } from 'chai';
 import { MarkerParser } from '../../src/parsers/marker.parser';
 
 describe('MarkerParser', () => {
-
 	const componentFilename: string = 'test.component.ts';
 
 	let parser: MarkerParser;
@@ -12,7 +11,6 @@ describe('MarkerParser', () => {
 		parser = new MarkerParser();
 	});
 
-
 	it('should extract strings using marker function', () => {
 		const contents = `
 			import { marker } from '@biesbjerg/ngx-translate-extract-marker';
@@ -35,11 +33,22 @@ describe('MarkerParser', () => {
 			_('Mix ' + \`of \` + 'different ' + \`types\`);
 		`;
 		const keys = parser.extract(contents, componentFilename).keys();
-		expect(keys).to.deep.equal([
-			'Hello world',
-			'This is a very very very very long line.',
-			'Mix of different types'
-		]);
+		expect(keys).to.deep.equal(['Hello world', 'This is a very very very very long line.', 'Mix of different types']);
+	});
+
+	it('should extract the strings', () => {
+		const contents = `
+		import { marker } from '@biesbjerg/ngx-translate-extract-marker';
+
+		export class AppModule {
+			constructor() {
+				marker('DYNAMIC_TRAD.val1');
+				marker('DYNAMIC_TRAD.val2');
+			}
+		}
+		`;
+		const keys = parser.extract(contents, componentFilename).keys();
+		expect(keys).to.deep.equal(['DYNAMIC_TRAD.val1', 'DYNAMIC_TRAD.val2']);
 	});
 
 });

tests/parsers/pipe.parser.spec.ts

@@ -3,7 +3,6 @@ import { expect } from 'chai';
 import { PipeParser } from '../../src/parsers/pipe.parser';
 
 describe('PipeParser', () => {
-
 	const templateFilename: string = 'test.template.html';
 
 	let parser: PipeParser;
@@ -30,12 +29,42 @@ describe('PipeParser', () => {
 		expect(keys).to.deep.equal(['World']);
 	});
 
-	it('should extract interpolated strings when translate pipe is used in conjunction with other pipes', () => {
+	it('should extract interpolated strings when translate pipe is used before other pipes', () => {
 		const contents = `Hello {{ 'World' | translate | upper }}`;
 		const keys = parser.extract(contents, templateFilename).keys();
 		expect(keys).to.deep.equal(['World']);
 	});
 
+	it('should extract interpolated strings when translate pipe is used after other pipes', () => {
+		const contents = `Hello {{ 'World'  | upper | translate }}`;
+		const keys = parser.extract(contents, templateFilename).keys();
+		expect(keys).to.deep.equal(['World']);
+	});
+
+	it('should extract strings from ternary operators inside interpolations', () => {
+		const contents = `{{ (condition ? 'Hello' : 'World') | translate }}`;
+		const keys = parser.extract(contents, templateFilename).keys();
+		expect(keys).to.deep.equal(['Hello', 'World']);
+	});
+
+	it('should extract strings from ternary operators inside attribute bindings', () => {
+		const contents = `<span [attr]="(condition ? 'Hello' : 'World') | translate"></span>`;
+		const keys = parser.extract(contents, templateFilename).keys();
+		expect(keys).to.deep.equal(['Hello', 'World']);
+	});
+
+	it('should extract strings from nested ternary operators ', () => {
+		const contents = `<h3>{{ (condition ? 'Hello' : anotherCondition ? 'Nested' : 'World' ) | translate }}</h3>`;
+		const keys = parser.extract(contents, templateFilename).keys();
+		expect(keys).to.deep.equal(['Hello', 'Nested', 'World']);
+	});
+
+	it('should extract strings from ternary operators inside attribute interpolations', () => {
+		const contents = `<span attr="{{(condition ? 'Hello' : 'World') | translate}}"></span>`;
+		const keys = parser.extract(contents, templateFilename).keys();
+		expect(keys).to.deep.equal(['Hello', 'World']);
+	});
+
 	it('should extract strings with escaped quotes', () => {
 		const contents = `Hello {{ 'World\\'s largest potato' | translate }}`;
 		const keys = parser.extract(contents, templateFilename).keys();
@@ -60,7 +89,7 @@ describe('PipeParser', () => {
 		expect(keys).to.deep.equal(['Hello World']);
 	});
 
-	it('should not use a greedy regular expression', () => {
+	it('should extract multiple entries from nodes', () => {
 		const contents = `
 			<ion-header>
 				<ion-navbar color="brand">
@@ -119,4 +148,15 @@ describe('PipeParser', () => {
 		expect(keys).to.deep.equal(['message']);
 	});
 
+	it('should ignore calculated values', () => {
+		const contents = `{{ 'SOURCES.' + source.name + '.NAME_PLURAL' | translate }}`;
+		const keys = parser.extract(contents, templateFilename).keys();
+		expect(keys).to.deep.equal([]);
+	});
+
+	it('should not extract pipe argument', () => {
+		const contents = `{{ value | valueToTranslationKey: 'argument' | translate }}`;
+		const keys = parser.extract(contents, templateFilename).keys();
+		expect(keys).to.deep.equal([]);
+	});
 });

tests/parsers/service.parser.spec.ts

@@ -2,18 +2,25 @@ import { expect } from 'chai';
 
 import { ServiceParser } from '../../src/parsers/service.parser';
 
-class TestServiceParser extends ServiceParser {
-
-}
-
 describe('ServiceParser', () => {
-
 	const componentFilename: string = 'test.component.ts';
 
-	let parser: TestServiceParser;
+	let parser: ServiceParser;
 
 	beforeEach(() => {
-		parser = new TestServiceParser();
+		parser = new ServiceParser();
+	});
+
+	it('should extract strings when TranslateService is accessed directly via constructor parameter', () => {
+		const contents = `
+			@Component({ })
+			export class MyComponent {
+				public constructor(protected translateService: TranslateService) {
+					translateService.get('It works!');
+				}
+		`;
+		const keys = parser.extract(contents, componentFilename).keys();
+		expect(keys).to.deep.equal(['It works!']);
 	});
 
 	it('should support extracting binary expressions', () => {
@@ -44,7 +51,7 @@ describe('ServiceParser', () => {
 		expect(keys).to.deep.equal(['Fallback message']);
 	});
 
-	it('should extract strings in TranslateService\'s get() method', () => {
+	it("should extract strings in TranslateService's get() method", () => {
 		const contents = `
 			@Component({ })
 			export class AppComponent {
@@ -57,7 +64,7 @@ describe('ServiceParser', () => {
 		expect(keys).to.deep.equal(['Hello World']);
 	});
 
-	it('should extract strings in TranslateService\'s instant() method', () => {
+	it("should extract strings in TranslateService's instant() method", () => {
 		const contents = `
 			@Component({ })
 			export class AppComponent {
@@ -70,7 +77,7 @@ describe('ServiceParser', () => {
 		expect(keys).to.deep.equal(['Hello World']);
 	});
 
-	it('should extract strings in TranslateService\'s stream() method', () => {
+	it("should extract strings in TranslateService's stream() method", () => {
 		const contents = `
 			@Component({ })
 			export class AppComponent {
@@ -83,7 +90,7 @@ describe('ServiceParser', () => {
 		expect(keys).to.deep.equal(['Hello World']);
 	});
 
-	it('should extract array of strings in TranslateService\'s get() method', () => {
+	it("should extract array of strings in TranslateService's get() method", () => {
 		const contents = `
 			@Component({ })
 			export class AppComponent {
@@ -96,7 +103,7 @@ describe('ServiceParser', () => {
 		expect(keys).to.deep.equal(['Hello', 'World']);
 	});
 
-	it('should extract array of strings in TranslateService\'s instant() method', () => {
+	it("should extract array of strings in TranslateService's instant() method", () => {
 		const contents = `
 			@Component({ })
 			export class AppComponent {
@@ -109,7 +116,7 @@ describe('ServiceParser', () => {
 		expect(key).to.deep.equal(['Hello', 'World']);
 	});
 
-	it('should extract array of strings in TranslateService\'s stream() method', () => {
+	it("should extract array of strings in TranslateService's stream() method", () => {
 		const contents = `
 			@Component({ })
 			export class AppComponent {
@@ -298,5 +305,4 @@ describe('ServiceParser', () => {
 		const keys = parser.extract(contents, componentFilename).keys();
 		expect(keys).to.deep.equal(['Back']);
 	});
-
 });

tests/parsers/utils.spec.ts

@@ -3,7 +3,6 @@ import { expect } from 'chai';
 import { isPathAngularComponent, extractComponentInlineTemplate } from '../../src/utils/utils';
 
 describe('Utils', () => {
-
 	it('should recognize js extension as angular component', () => {
 		const result = isPathAngularComponent('test.js');
 		expect(result).to.equal(true);
@@ -63,5 +62,4 @@ describe('Utils', () => {
 		const template = extractComponentInlineTemplate(contents);
 		expect(template).to.equal('\n\t\t\t\t\t<p>\n\t\t\t\t\t\tHello World\n\t\t\t\t\t</p>\n\t\t\t\t');
 	});
-
 });

tests/post-processors/key-as-default-value.post-processor.spec.ts

@@ -5,7 +5,6 @@ import { KeyAsDefaultValuePostProcessor } from '../../src/post-processors/key-as
 import { TranslationCollection } from '../../src/utils/translation.collection';
 
 describe('KeyAsDefaultValuePostProcessor', () => {
-
 	let processor: PostProcessorInterface;
 
 	beforeEach(() => {
@@ -27,5 +26,4 @@ describe('KeyAsDefaultValuePostProcessor', () => {
 			'Use this key as value as well': 'Use this key as value as well'
 		});
 	});
-
 });

tests/post-processors/null-as-default-value.post-processor.spec.ts

@@ -5,7 +5,6 @@ import { NullAsDefaultValuePostProcessor } from '../../src/post-processors/null-
 import { TranslationCollection } from '../../src/utils/translation.collection';
 
 describe('NullAsDefaultValuePostProcessor', () => {
-
 	let processor: PostProcessorInterface;
 
 	beforeEach(() => {
@@ -38,5 +37,4 @@ describe('NullAsDefaultValuePostProcessor', () => {
 			'String A': 'Streng A'
 		});
 	});
-
 });

tests/post-processors/purge-obsolete-keys.post-processor.spec.ts

@@ -5,15 +5,14 @@ import { PurgeObsoleteKeysPostProcessor } from '../../src/post-processors/purge-
 import { TranslationCollection } from '../../src/utils/translation.collection';
 
 describe('PurgeObsoleteKeysPostProcessor', () => {
-
-	let processor: PostProcessorInterface;
+	let postProcessor: PostProcessorInterface;
 
 	beforeEach(() => {
-		processor = new PurgeObsoleteKeysPostProcessor();
+		postProcessor = new PurgeObsoleteKeysPostProcessor();
 	});
 
 	it('should purge obsolete keys', () => {
-		const collection = new TranslationCollection({
+		const draft = new TranslationCollection({
 			'I am completely new': '',
 			'I already exist': '',
 			'I already exist but was not present in extract': ''
@@ -27,10 +26,9 @@ describe('PurgeObsoleteKeysPostProcessor', () => {
 			'I already exist but was not present in extract': ''
 		});
 
-		expect(processor.process(collection, extracted, existing).values).to.deep.equal({
+		expect(postProcessor.process(draft, extracted, existing).values).to.deep.equal({
 			'I am completely new': '',
 			'I already exist': ''
 		});
 	});
-
 });

tests/post-processors/sort-by-key.post-processor.spec.ts

@@ -5,7 +5,6 @@ import { SortByKeyPostProcessor } from '../../src/post-processors/sort-by-key.po
 import { TranslationCollection } from '../../src/utils/translation.collection';
 
 describe('SortByKeyPostProcessor', () => {
-
 	let processor: PostProcessorInterface;
 
 	beforeEach(() => {
@@ -14,20 +13,19 @@ describe('SortByKeyPostProcessor', () => {
 
 	it('should sort keys alphanumerically', () => {
 		const collection = new TranslationCollection({
-			'z': 'last value',
-			'a': 'a value',
+			z: 'last value',
+			a: 'a value',
 			'9': 'a numeric key',
-			'b': 'another value'
+			b: 'another value'
 		});
 		const extracted = new TranslationCollection();
 		const existing = new TranslationCollection();
 
 		expect(processor.process(collection, extracted, existing).values).to.deep.equal({
 			'9': 'a numeric key',
-			'a': 'a value',
-			'b': 'another value',
-			'z': 'last value'
+			a: 'a value',
+			b: 'another value',
+			z: 'last value'
 		});
 	});
-
 });

tests/post-processors/string-as-default-value.post-processor.spec.ts

@@ -0,0 +1,40 @@
+import { expect } from 'chai';
+
+import { PostProcessorInterface } from '../../src/post-processors/post-processor.interface';
+import { StringAsDefaultValuePostProcessor } from '../../src/post-processors/string-as-default-value.post-processor';
+import { TranslationCollection } from '../../src/utils/translation.collection';
+
+describe('StringAsDefaultValuePostProcessor', () => {
+	let processor: PostProcessorInterface;
+
+	beforeEach(() => {
+		processor = new StringAsDefaultValuePostProcessor({ defaultValue: 'default' });
+	});
+
+	it('should use string as default value', () => {
+		const draft = new TranslationCollection({ 'String A': '' });
+		const extracted = new TranslationCollection({ 'String A': '' });
+		const existing = new TranslationCollection();
+		expect(processor.process(draft, extracted, existing).values).to.deep.equal({
+			'String A': 'default'
+		});
+	});
+
+	it('should keep existing value even if it is an empty string', () => {
+		const draft = new TranslationCollection({ 'String A': '' });
+		const extracted = new TranslationCollection({ 'String A': '' });
+		const existing = new TranslationCollection({ 'String A': '' });
+		expect(processor.process(draft, extracted, existing).values).to.deep.equal({
+			'String A': ''
+		});
+	});
+
+	it('should keep existing value', () => {
+		const draft = new TranslationCollection({ 'String A': 'Streng A' });
+		const extracted = new TranslationCollection({ 'String A': 'Streng A' });
+		const existing = new TranslationCollection({ 'String A': 'Streng A' });
+		expect(processor.process(draft, extracted, existing).values).to.deep.equal({
+			'String A': 'Streng A'
+		});
+	});
+});

tests/utils/translation.collection.spec.ts

@@ -3,7 +3,6 @@ import { expect } from 'chai';
 import { TranslationCollection } from '../../src/utils/translation.collection';
 
 describe('StringCollection', () => {
-
 	let collection: TranslationCollection;
 
 	beforeEach(() => {
@@ -64,12 +63,15 @@ describe('StringCollection', () => {
 	it('should merge with other collection', () => {
 		collection = collection.add('oldKey', 'oldVal');
 		const newCollection = new TranslationCollection({ newKey: 'newVal' });
-		expect(collection.union(newCollection).values).to.deep.equal({ oldKey: 'oldVal', newKey: 'newVal' });
+		expect(collection.union(newCollection).values).to.deep.equal({
+			oldKey: 'oldVal',
+			newKey: 'newVal'
+		});
 	});
 
 	it('should intersect with passed collection', () => {
 		collection = collection.addKeys(['red', 'green', 'blue']);
-		const newCollection = new TranslationCollection( { red: '', blue: '' });
+		const newCollection = new TranslationCollection({ red: '', blue: '' });
 		expect(collection.intersect(newCollection).values).to.deep.equal({ red: '', blue: '' });
 	});
 
@@ -88,7 +90,10 @@ describe('StringCollection', () => {
 	it('should map values', () => {
 		collection = new TranslationCollection({ red: 'rød', green: 'grøn', blue: 'blå' });
 		collection = collection.map((key, val) => 'mapped value');
-		expect(collection.values).to.deep.equal({ red: 'mapped value', green: 'mapped value', blue: 'mapped value' });
+		expect(collection.values).to.deep.equal({
+			red: 'mapped value',
+			green: 'mapped value',
+			blue: 'mapped value'
+		});
 	});
-
 });

tsconfig.json

@@ -3,21 +3,25 @@
         "allowSyntheticDefaultImports": true,
         "noUnusedLocals": true,
         "noImplicitAny": true,
+        "noImplicitReturns": true,
+        "noImplicitThis": true,
+        "noImplicitUseStrict": true,
         "removeComments": true,
         "declaration": true,
         "target": "es2015",
         "lib": [
             "dom",
-            "es2018"
+            "esnext.array"
         ],
         "module": "commonjs",
-        "outDir": "./dist/",
-        "sourceMap": true
+        "outDir": "dist",
+        "sourceMap": true,
+        "typeRoots" : [
+            "node_modules/@types"
+        ]
     },
     "include": [
         "src/**/*.ts"
     ],
-    "exclude": [
-        "node_modules"
-    ]
+    "exclude": []
 }

tslint.commit.json

@@ -0,0 +1,8 @@
+{
+  "extends": ["./tslint.json", "tslint-etc"],
+  "jsRules": {},
+  "rules": {
+    "ordered-imports": false,
+    "no-unused-declaration": true
+  }
+}

tslint.json

@@ -1,53 +1,117 @@
 {
-	"rulesDirectory": [
-		"node_modules/tslint-eslint-rules/dist/rules"
-	],
-	"rules": {
-		"indent": [true, "tabs"],
-		"semicolon": [true, "always", "ignore-interfaces"],
-		"quotemark": [true, "single", "avoid-escape"],
-		"only-arrow-functions": false,
-		"no-duplicate-variable": true,
-		"member-access": true,
-		"member-ordering": [
-			true,
-			{
-				"order": [
-					"public-static-field",
-					"public-static-method",
-					"protected-static-field",
-					"protected-static-method",
-					"private-static-field",
-					"private-static-method",
-					"public-instance-field",
-					"protected-instance-field",
-					"private-instance-field",
-					"constructor",
-					"public-instance-method",
-					"protected-instance-method",
-					"private-instance-method"
-				]
-			}
-		],
-		"curly": true,
-		"eofline": true,
-		"no-trailing-whitespace": true,
-		"trailing-comma": [
-			true,
-			{
-				"multiline": "never",
-				"singleline": "never"
-			}
-		],
-		"whitespace": [
-			true,
-			"check-branch",
-			"check-decl",
-			"check-operator",
-			"check-module",
-			"check-separator",
-			"check-type",
-			"check-typecast"
-		]
-	}
-}
+  "defaultSeverity": "error",
+  "extends": [
+    "tslint-config-prettier"
+  ],
+  "rules": {
+    "arrow-return-shorthand": true,
+    "callable-types": true,
+    "class-name": true,
+    "comment-format": [
+      true,
+      "check-space"
+    ],
+    "curly": true,
+    "deprecation": {
+      "severity": "warn"
+    },
+    "eofline": true,
+    "forin": true,
+    "import-spacing": true,
+    "indent": [
+      true,
+      "tabs"
+    ],
+    "interface-over-type-literal": true,
+    "label-position": true,
+    "max-line-length": [
+      true,
+      220
+    ],
+    "member-access": false,
+    "member-ordering": [
+      true,
+      {
+        "order": [
+          "static-field",
+          "instance-field",
+          "static-method",
+          "instance-method"
+        ]
+      }
+    ],
+    "no-arg": true,
+    "no-bitwise": true,
+    "no-console": [
+      true,
+      "debug",
+      "info",
+      "time",
+      "timeEnd",
+      "trace"
+    ],
+    "no-construct": true,
+    "no-debugger": true,
+    "no-duplicate-super": true,
+    "no-empty": false,
+    "no-empty-interface": true,
+    "no-eval": true,
+    "no-inferrable-types": [
+      false,
+      "ignore-params"
+    ],
+    "no-misused-new": true,
+    "no-non-null-assertion": true,
+    "no-shadowed-variable": true,
+    "no-string-literal": false,
+    "no-string-throw": true,
+    "no-switch-case-fall-through": true,
+    "no-trailing-whitespace": true,
+    "no-unnecessary-initializer": true,
+    "no-unused-expression": true,
+    "no-var-keyword": true,
+    "object-literal-sort-keys": false,
+    "one-line": [
+      true,
+      "check-open-brace",
+      "check-catch",
+      "check-else",
+      "check-whitespace"
+    ],
+    "prefer-const": true,
+    "radix": true,
+    "semicolon": [
+      true,
+      "always"
+    ],
+    "triple-equals": [
+      true,
+      "allow-null-check"
+    ],
+    "typedef-whitespace": [
+      true,
+      {
+        "call-signature": "nospace",
+        "index-signature": "nospace",
+        "parameter": "nospace",
+        "property-declaration": "nospace",
+        "variable-declaration": "nospace"
+      }
+    ],
+    "unified-signatures": true,
+    "variable-name": [
+      true,
+      "ban-keywords",
+      "allow-pascal-case",
+      "check-format"
+    ],
+    "whitespace": [
+      true,
+      "check-branch",
+      "check-decl",
+      "check-operator",
+      "check-separator",
+      "check-type"
+    ]
+  }
+}