From 37bcddb3e7247ada9dceca821eaaecfbc5cbde4f Mon Sep 17 00:00:00 2001
From: Yu Shimura <mail@yuhr.org>
Date: Sat, 1 Dec 2018 11:55:06 +0900
Subject: [PATCH] Parsed result now statically typed

---
 types/binary-parser/binary-parser-tests.ts |  25 +++
 types/binary-parser/index.d.ts             | 187 ++++++++++++---------
 2 files changed, 133 insertions(+), 79 deletions(-)

diff --git a/types/binary-parser/binary-parser-tests.ts b/types/binary-parser/binary-parser-tests.ts
index d0d09e5ef7..9eca89211c 100644
--- a/types/binary-parser/binary-parser-tests.ts
+++ b/types/binary-parser/binary-parser-tests.ts
@@ -93,3 +93,28 @@ const parser5 = new Parser()
         length: '4',
         formatter: (arr) => { }
     });
+
+const parser6 = new Parser()
+    .nest("nested", {
+        type: new Parser()
+            .array("points", {
+                type: new Parser()
+                    .uint8("x")
+                    .uint8("y"),
+                length: 2
+            })
+    })
+    .choice("optional", {
+        tag: "nested.points[0].x",
+        choices: {
+            1: new Parser()
+                .uint8("number")
+        }
+    });
+
+const result = parser6.parse(Buffer.from([0x01, 0x02, 0x03, 0x04, 0x05]));
+
+// See the inferred static types on the IntelliSense.
+result.nested.points[0].x;
+result.nested.points[1].y;
+result.optional.number;
diff --git a/types/binary-parser/index.d.ts b/types/binary-parser/index.d.ts
index 657996bd8d..b16f433e55 100644
--- a/types/binary-parser/index.d.ts
+++ b/types/binary-parser/index.d.ts
@@ -1,88 +1,117 @@
 // Type definitions for binary-parser 1.3
 // Project: https://github.com/keichi/binary-parser
-// Definitions by: Benjamin Riggs <https://github.com/riggs>, Dolan Miu <https://github.com/dolanmiu>
+// Definitions by: Benjamin Riggs <https://github.com/riggs>,
+//                 Dolan Miu <https://github.com/dolanmiu>,
+//                 Yu Shimura <https://github.com/yuhr>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.8
 
 /// <reference types="node" />
 
-export interface Parser {
-    parse(buffer: Buffer, callback?: (err?: Error, result?: any) => void): Parser.Parsed;
+export interface Parser<O extends object | undefined = undefined> {
+    parse(buffer: Buffer, callback?: (err?: Error, result?: any) => void): Parser.Parsed<O>;
 
     create(constructorFunction: ObjectConstructor): Parser;
 
-    int8(name: string, options?: Parser.Options): Parser;
-    uint8(name: string, options?: Parser.Options): Parser;
+    int8<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    uint8<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
 
-    int16(name: string, options?: Parser.Options): Parser;
-    uint16(name: string, options?: Parser.Options): Parser;
-    int16le(name: string, options?: Parser.Options): Parser;
-    int16be(name: string, options?: Parser.Options): Parser;
-    uint16le(name: string, options?: Parser.Options): Parser;
-    uint16be(name: string, options?: Parser.Options): Parser;
+    int16<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    uint16<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    int16le<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    int16be<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    uint16le<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    uint16be<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
 
-    int32(name: string, options?: Parser.Options): Parser;
-    uint32(name: string, options?: Parser.Options): Parser;
-    int32le(name: string, options?: Parser.Options): Parser;
-    int32be(name: string, options?: Parser.Options): Parser;
-    uint32le(name: string, options?: Parser.Options): Parser;
-    uint32be(name: string, options?: Parser.Options): Parser;
+    int32<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    uint32<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    int32le<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    int32be<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    uint32le<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    uint32be<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
 
-    bit1(name: string, options?: Parser.Options): Parser;
-    bit2(name: string, options?: Parser.Options): Parser;
-    bit3(name: string, options?: Parser.Options): Parser;
-    bit4(name: string, options?: Parser.Options): Parser;
-    bit5(name: string, options?: Parser.Options): Parser;
-    bit6(name: string, options?: Parser.Options): Parser;
-    bit7(name: string, options?: Parser.Options): Parser;
-    bit8(name: string, options?: Parser.Options): Parser;
-    bit9(name: string, options?: Parser.Options): Parser;
-    bit10(name: string, options?: Parser.Options): Parser;
-    bit11(name: string, options?: Parser.Options): Parser;
-    bit12(name: string, options?: Parser.Options): Parser;
-    bit13(name: string, options?: Parser.Options): Parser;
-    bit14(name: string, options?: Parser.Options): Parser;
-    bit15(name: string, options?: Parser.Options): Parser;
-    bit16(name: string, options?: Parser.Options): Parser;
-    bit17(name: string, options?: Parser.Options): Parser;
-    bit18(name: string, options?: Parser.Options): Parser;
-    bit19(name: string, options?: Parser.Options): Parser;
-    bit20(name: string, options?: Parser.Options): Parser;
-    bit21(name: string, options?: Parser.Options): Parser;
-    bit22(name: string, options?: Parser.Options): Parser;
-    bit23(name: string, options?: Parser.Options): Parser;
-    bit24(name: string, options?: Parser.Options): Parser;
-    bit25(name: string, options?: Parser.Options): Parser;
-    bit26(name: string, options?: Parser.Options): Parser;
-    bit27(name: string, options?: Parser.Options): Parser;
-    bit28(name: string, options?: Parser.Options): Parser;
-    bit29(name: string, options?: Parser.Options): Parser;
-    bit30(name: string, options?: Parser.Options): Parser;
-    bit31(name: string, options?: Parser.Options): Parser;
-    bit32(name: string, options?: Parser.Options): Parser;
+    bit1<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    bit2<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    bit3<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    bit4<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    bit5<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    bit6<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    bit7<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    bit8<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    bit9<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    bit10<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    bit11<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    bit12<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    bit13<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    bit14<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    bit15<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    bit16<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    bit17<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    bit18<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    bit19<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    bit20<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    bit21<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    bit22<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    bit23<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    bit24<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    bit25<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    bit26<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    bit27<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    bit28<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    bit29<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    bit30<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    bit31<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    bit32<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
 
-    float(name: string, options?: Parser.Options): Parser;
-    floatle(name: string, options?: Parser.Options): Parser;
-    floatbe(name: string, options?: Parser.Options): Parser;
+    float<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    floatle<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    floatbe<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
 
-    double(name: string, options?: Parser.Options): Parser;
-    doublele(name: string, options?: Parser.Options): Parser;
-    doublebe(name: string, options?: Parser.Options): Parser;
+    double<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    doublele<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
+    doublebe<N extends string>(name: N, options?: Parser.Options): Parser.Next<O, N, number>;
 
-    string(name: string, options?: Parser.StringOptions): Parser;
+    string<N extends string>(name: N, options?: Parser.StringOptions): Parser.Next<O, N, string>;
 
-    buffer(name: string, options: Parser.BufferOptions): Parser;
+    buffer<N extends string>(name: N, options: Parser.BufferOptions): Parser.Next<O, N, Buffer>;
 
-    array(name: string, options: Parser.ArrayOptions): Parser;
+    array<N extends string, Q extends Parser.ArrayOptions>(name: N, options: Q): Parser.Next<O, N,
+        Q extends { type: infer T }
+            ? T extends Parser<infer O>
+                ? O extends undefined ? Array<{}> : O[]
+                : T extends string
+                    ? number[]
+                    : never
+            : never
+    >;
 
-    choice(name: string, options: Parser.ChoiceOptions): Parser;
+    choice<N extends string, Q extends Parser.ChoiceOptions>(name: N, options: Q): Parser.Next<O, N,
+        Q extends {
+            choices: infer C
+        }
+            ? C extends {
+                [key in keyof C]: infer T
+            }
+                ? T extends Parser<infer O>
+                    ? O extends undefined ? {} : O
+                    : T extends string ? any : never
+                : never
+            : never
+    >;
 
-    nest(name: string, options: Parser.NestOptions): Parser;
+    nest<N extends string, Q extends Parser.NestOptions>(name: N, options: Q): Parser.Next<O, N,
+        Q extends { type: infer T }
+            ? T extends Parser<infer O>
+                ? O extends undefined ? {} : O
+                : never
+            : never
+    >;
 
-    skip(length: number): Parser;
+    skip(length: number): Parser<O>;
 
-    endianess(endianess: Parser.Endianness): Parser;   /* [sic] */
+    endianess(endianess: Parser.Endianness): Parser<O>;   /* [sic] */
 
-    namely(alias: string): Parser;
+    namely(alias: string): Parser<O>;
 
     compile(): void;
 
@@ -96,10 +125,8 @@ export interface ParserConstructor {
 export const Parser: ParserConstructor;
 
 export namespace Parser {
-    type Data = number | string | Array<number | Parsed> | Parsed | Buffer;
-    interface Parsed {
-        [name: string]: Data;
-    }
+    type Data = number | string | Array<number | Parser<any>> | Parser<any> | Buffer;
+    type Parsed<O extends object | undefined> = O extends undefined ? {} : O;
 
     interface Options {
         formatter?: ((value: Data) => any);
@@ -108,7 +135,7 @@ export namespace Parser {
 
     interface StringOptions extends Options {
         encoding?: string;
-        length?: number | string | ((this: Parsed) => number);
+        length?: number | string | ((this: Parser<any>) => number);
         zeroTerminated?: boolean;
         greedy?: boolean;
         stripNull?: boolean;
@@ -116,32 +143,34 @@ export namespace Parser {
 
     interface BufferOptions extends Options {
         clone?: boolean;
-        length?: number | string | ((this: Parsed) => number);
+        length?: number | string | ((this: Parser<any>) => number);
         readUntil?: string | ((item: number, buffer: Buffer) => boolean);
     }
 
     interface ArrayOptions extends Options {
-        type: string | Parser;
-        length?: number | string | ((this: Parsed) => number);
-        lengthInBytes?: number | string | ((this: Parsed) => number);
+        type: string | Parser<any>;
+        length?: number | string | ((this: Parser<any>) => number);
+        lengthInBytes?: number | string | ((this: Parser<any>) => number);
         readUntil?: string | ((item: number, buffer: Buffer) => boolean);
     }
 
     interface ChoiceOptions extends Options {
-        tag: string | ((this: Parsed) => number);
-        choices: { [item: number]: Parser | string };
-        defaultChoice?: Parser | string;
+        tag: string | ((this: Parser<any>) => number);
+        choices: { [item: number]: Parser<any> | string };
+        defaultChoice?: Parser<any> | string;
     }
 
     interface NestOptions extends Options {
-        type: Parser | string;
+        type: Parser<any>;
     }
 
     type Endianness =
         'little' |
         'big';
 
-    interface Context {
-        [name: string]: Parsed;
-    }
+    type Valid<O extends object | undefined, P extends object> =
+        O extends undefined ? P : O & P;
+
+    type Next<O extends object | undefined, N extends string, T extends any> =
+        Parser<Valid<O, { [name in N]: T }>>;
 }