Fix typescript circular ref errors and typing improvements

.gitignore

@@ -1,2 +1,5 @@
 .vscode
-node_modules
+node_modules
+*.map
+*.js
+*.d.ts

docs/testFail.ts

@@ -1,7 +1,12 @@
+import {typedPath as tp} from '../index';
+
 type TestType = {
     a: {
+        testFunc: () => { result: string },
         b: {
+            arrayOfArrays: string[][]
             c: number;
+            f: { test: string, blah: { path?: string }, arr: string[] }[];
         }
     }
 };
@@ -10,7 +15,29 @@ function getField(path: string, object: any) {
     return 'Here should be some logic to get field by path';
 }
 
-const testObject: TestType = {a: {b: {c: 5}}};
-const field = getField('a.b.c', testObject); // <- Look! No error and type protection here!
+const testObject: TestType = {
+    a: {
+        b: {
+            arrayOfArrays: [['hi']],
+            c: 5,
+            f: [{test: 'tes123t', blah: {path: '123123'}, arr: ['tt']}]
+        }
+    }
+};
+
+// Look! No error and type protection here!
+const field = getField('a.b.c', testObject);
+
+// f is an array you cant access it directly
+console.log(tp<TestType>().a.b.f.blah.$path);
+
+// f is not an array of arrays just a plain string array so double accessor fails
+console.log(tp<TestType>().a.b.f[0][0].$path);
+
+// a is not a func
+console.log(tp<TestType>().a().$path);
+
+// bad is not a field in the function return type
+console.log(tp<TestType>().a.testFunc.bad);
 
 export default TestType;

index.spec.ts

@@ -1,16 +1,43 @@
 import {expect} from 'chai';
-import {typedPath} from './index';
+import {typedPath as tp, typedPath} from './index';
+
+type TestType = {
+    a: {
+        testFunc: () => { result: string },
+        b: {
+            arrayOfArrays: string[][]
+            c: number;
+            f: { test: string, blah: { path?: string }, arr: string[] }[];
+        }
+    }
+};
 
 describe('Typed path', () => {
     it('should get field path', () => {
-        type TestType = {a: {b: {c: number}}};
-
-        expect(typedPath<TestType>().a.b.c.path()).to.equal('a.b.c');
+        expect(typedPath<TestType>().a.b.c.$path).to.equal('a.b.c');
     });
 
     it('should get index path', () => {
-        type TestType = {a: {b: [{c: number}]}};
+        expect(tp<TestType>().a.b.f[3].$path).to.equal('a.b.f[3]');
+    });
+
+    it('should get path for toString()', () => {
+        expect(tp<TestType>().a.b.f[3].blah.path.toString()).to.equal('a.b.f[3].blah.path');
+    });
+
+    it('should get index of index for array of array ', () => {
+        expect(tp<TestType>().a.b.arrayOfArrays[3][3].$path).to.equal('a.b.arrayOfArrays[3][3]');
+    });
+
+    it('should get array node', () => {
+        expect(tp<TestType>().a.b.f.$path).to.equal('a.b.f');
+    });
+
+    it('should get function return type path', () => {
+        expect(tp<TestType>().a.testFunc.result.$path).to.equal('a.testFunc.result');
+    });
 
-        expect(typedPath<TestType>().a.b[5].c.path()).to.equal('a.b[5].c');
+    it('should get function path', () => {
+        expect(tp<TestType>().a.testFunc.$path).to.equal('a.testFunc');
     });
-});
+});

index.ts

@@ -1,20 +1,31 @@
-export type TypedPathWrapper<T> = {
-    [P in keyof T]: TypedPathWrapper<T[P]>;
-} &
-{
-    (): T;
-    [index: number]: TypedPathWrapper<T[any]>;
-    path: () => string;
+export type TypedPathNode<T> = {
+    $path: string;
 };
 
+export type TypedPathFunction<T> = (...args: any[]) => T;
+
+export type TypedPathWrapper<T> = (T extends Array<infer Z>
+    ? {
+        [index: number]: TypedPathWrapper<Z>;
+    }
+    : T extends TypedPathFunction<infer RET>
+        ? {
+            (): TypedPathWrapper<RET>;
+        } & {
+            [P in keyof RET]: TypedPathWrapper<RET[P]>;
+        }
+        : {
+            [P in keyof T]: TypedPathWrapper<T[P]>;
+        }
+    ) & TypedPathNode<T>;
+
 const toStringMethods: (string | symbol | number)[] = [
     'toString',
-    'path',
     Symbol.toStringTag,
     'valueOf'
 ];
 
-function pathToString (path: string[]): string {
+function pathToString(path: string[]): string {
     return path.reduce((current, next) => {
         if (+next === +next) {
             current += `[${next}]`;
@@ -29,6 +40,10 @@ function pathToString (path: string[]): string {
 export function typedPath<T>(path: string[] = []): TypedPathWrapper<T> {
     return <TypedPathWrapper<T>>new Proxy({}, {
         get(target: T, name: string | symbol | number) {
+            if (name === '$path') {
+                return pathToString(path);
+            }
+
             if (toStringMethods.includes(name)) {
                 return () => pathToString(path);
             }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "typed-path",
-  "version": "1.0.3",
+  "version": "2.0.0",
   "description": "Type safe object string paths for typescript.",
   "main": "index.js",
   "repository": {
@@ -37,9 +37,9 @@
     "@types/mocha": "^2.2.39",
     "chai": "^3.5.0",
     "husky": "^0.13.1",
-    "mocha": "^3.2.0",
-    "ts-node": "^2.1.0",
+    "mocha": "^6.2.0",
+    "ts-node": "8.3.0",
     "tslint": "^4.4.2",
-    "typescript": "^2.2.1"
+    "typescript": "3.6.4"
   }
 }