added parser for limitTo Angular filter

__tests__/parser/parse-ng-iterator.spec.ts

@@ -0,0 +1,61 @@
+import parseNgIterator from '../../src/parser/parse-ng-iterator';
+
+describe('Parser', () => {
+    describe('parseNgIterator()', () => {
+        it('should throw an error for invalid expression', () => {
+            let error: Error;
+
+            try {
+                parseNgIterator('Test expression');
+            } catch (e) {
+                error = e;
+            }
+
+            expect(error).toEqual(new Error('Invalid iterator expression \'Test expression\''));
+        });
+
+        it('should throw an error for invalid left-side expression of the iterator', () => {
+            let error: Error;
+
+            try {
+                parseNgIterator('() in numbers');
+            } catch (e) {
+                error = e;
+            }
+
+            expect(error).toEqual(new Error('Invalid left-side expression () in iterator \'() in numbers\''));
+        });
+
+        it('should throw an error for invalid alias in the iterator', () => {
+            let error: Error;
+
+            try {
+                parseNgIterator('number in numbers as this');
+            } catch (e) {
+                error = e;
+            }
+
+            expect(error).toEqual(new Error(
+                'Iterator alias this is invalid - must be a valid JS identifier which is not a reserved name'
+            ));
+        });
+
+        it('should convert limitTo filter', () => {
+            expect(parseNgIterator('number in numbers | limitTo:numLimit')).toEqual({
+                aliasAs: undefined,
+                collectionIdentifier: 'numbers',
+                collectionTransform: ['.slice(0, 0 + numLimit)'],
+                keyIdentifier: undefined,
+                valueIdentifier: 'number'
+            });
+
+            expect(parseNgIterator('number in numbers | limitTo : numLimit : limitBegin')).toEqual({
+                aliasAs: undefined,
+                collectionIdentifier: 'numbers',
+                collectionTransform: ['.slice(limitBegin, limitBegin + numLimit)'],
+                keyIdentifier: undefined,
+                valueIdentifier: 'number'
+            });
+        });
+    });
+});

package.json

@@ -1,7 +1,7 @@
 {
   "name": "ng2react-builder",
   "description": "Builder of React.js components from Angular1 sources",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {

src/parser/parse-ng-iterator.ts

@@ -11,38 +11,45 @@ export default function parseNgIterator (expression: string): AngularIteratorInf
     let match: RegExpMatchArray = expression.match(pattern);
 
     if (!match) {
-        throw new Error(`Invalid iterator expression ${ expression }`);
+        throw new Error(`Invalid iterator expression '${ expression }'`);
     }
 
     const [, iteratorExp, collectionExp, aliasAs]: string[] = match;
 
     match = iteratorExp.match(iteratorExpPattern);
 
     if (!match) {
-        throw new Error(`Invalid left-side expression ${ iteratorExp } in iterator ${ expression }`);
+        throw new Error(`Invalid left-side expression ${ iteratorExp } in iterator '${ expression }'`);
     }
 
     const valueIdentifier: string = match[3] || match[1];
     const keyIdentifier: string = match[2];
 
     if (aliasAs && (!aliasPattern.test(aliasAs) || aliasReservedNamesPattern.test(aliasAs))) {
         throw new Error(
-            `Iterator alias ${ aliasAs } is invalid --- must be a valid JS identifier which is not a reserved name`
+            `Iterator alias ${ aliasAs } is invalid - must be a valid JS identifier which is not a reserved name`
         );
     }
 
     const collectionPipe: string[] = collectionExp.split(collectionExpSeparator);
     const collectionTransform: string[] = [];
 
     collectionPipe.slice(1).forEach((transform: string) => {
-        const [name, value] = transform.split(':');
+        const ngFilterData: string[] = transform.split(':');
+        const ngFilterName: string = ngFilterData[0].trim();
 
-        switch (name) {
+        switch (ngFilterName) {
             case 'filter':
-                collectionTransform.push(`.filter(${ value })`);
+                collectionTransform.push(`.filter(${ ngFilterData[1] })`);
                 break;
             case 'orderBy':
-                collectionTransform.push(`.sort(${ value })`);
+                collectionTransform.push(`.sort(${ ngFilterData[1] })`);
+                break;
+            case 'limitTo':
+                const limit: string = (ngFilterData[1] || '').trim();
+                const begin: string = (ngFilterData[2] || '').trim();
+
+                collectionTransform.push(`.slice(${ begin || 0 }, ${ begin || 0 } + ${ limit || 0 })`);
                 break;
             default:
                 //