bump version

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@biesbjerg/ngx-translate-extract",
-  "version": "5.0.1",
+  "version": "6.0.0",
   "description": "Extract strings from projects using ngx-translate",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",

src/parsers/directive.parser.ts

@@ -14,7 +14,7 @@ export class DirectiveParser implements ParserInterface {
 
 		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);
 		});
 
@@ -35,7 +35,7 @@ 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];
@@ -73,10 +73,15 @@ export class DirectiveParser implements ParserInterface {
 		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/service.parser.ts

@@ -1,8 +1,9 @@
+import { ClassDeclaration, CallExpression } from 'typescript';
 import { tsquery } from '@phenomnomnominal/tsquery';
 
 import { ParserInterface } from './parser.interface';
 import { TranslationCollection } from '../utils/translation.collection';
-import { findClassDeclarations, 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'];
@@ -19,12 +20,11 @@ export class ServiceParser implements ParserInterface {
 		let collection: TranslationCollection = new TranslationCollection();
 
 		classDeclarations.forEach(classDeclaration => {
-			const propName: string = findClassPropertyByType(classDeclaration, TRANSLATE_SERVICE_TYPE_REFERENCE);
-			if (!propName) {
-				return;
-			}
+			const callExpressions = [
+				...this.findConstructorParamCallExpressions(classDeclaration),
+				...this.findPropertyCallExpressions(classDeclaration)
+			];
 
-			const callExpressions = findMethodCallExpressions(classDeclaration, propName, TRANSLATE_SERVICE_METHOD_NAMES);
 			callExpressions.forEach(callExpression => {
 				const [firstArg] = callExpression.arguments;
 				if (!firstArg) {
@@ -36,4 +36,21 @@ export class ServiceParser implements ParserInterface {
 		});
 		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/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';
@@ -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,7 +97,7 @@ 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('|');
 	}

tests/app/login.html

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

tests/parsers/directive.parser.spec.ts

@@ -85,4 +85,32 @@ describe('DirectiveParser', () => {
 		const keys = parser.extract(contents, componentFilename).keys();
 		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

@@ -35,4 +35,20 @@ describe('MarkerParser', () => {
 		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']);
 	});
+
+	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

@@ -147,4 +147,16 @@ describe('PipeParser', () => {
 		const keys = parser.extract(contents, templateFilename).keys();
 		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

@@ -11,6 +11,18 @@ describe('ServiceParser', () => {
 		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', () => {
 		const contents = `
 			@Component({ })