Update/fix typedefs for listr (#36924)

* update typedefs for listr

* prettier fixes

* fix tests

* add to Definitions by section

* add renderer type tests

* make context generic

types/listr/index.d.ts

@@ -2,6 +2,7 @@
 // Project: https://github.com/samverschueren/listr#readme
 // Definitions by: Dusan Radovanovic <https://github.com/durad>
 //                 Vladislav Polyakov <https://github.com/polRk>
+//                 Jason Zukewich <https://github.com/jgzuke>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.8
 
@@ -11,41 +12,75 @@ import * as stream from "stream";
 import { Observable } from "rxjs";
 
 declare namespace Listr {
-    interface ListrRenderer {
-        nonTTY: boolean;
-        render(): void;
-        end(): void;
-    }
+    type ListrContext = any;
+    type ListrRendererValue<Ctx> = "silent" | "default" | "verbose" | ListrRendererClass<Ctx>;
+    type ListrTaskResult<Ctx> = string | Promise<any> | Listr<Ctx> | stream.Readable | Observable<any>;
 
-    interface ListrOptions {
+    interface ListrOptions<Ctx = ListrContext> {
         concurrent?: boolean | number;
         exitOnError?: boolean;
-        renderer?: "silent" | "default" | "verbose" | ListrRenderer;
-        nonTTYRenderer?: "silent" | "default" | "verbose" | ListrRenderer;
+        renderer?: ListrRendererValue<Ctx>;
+        nonTTYRenderer?: ListrRendererValue<Ctx>;
     }
 
-    interface ListrTask {
+    interface ListrEvent {
+        type: string;
+    }
+
+    interface ListrTask<Ctx = ListrContext> {
+        title: string;
+        task: (ctx: Ctx, task: ListrTaskWrapper<Ctx>) => void | ListrTaskResult<Ctx>;
+        skip?: (ctx: Ctx) => void | boolean | string | Promise<boolean>;
+        enabled?: (ctx: Ctx) => boolean | Promise<boolean> | Observable<boolean>;
+    }
+
+    interface ListrTaskObject<Ctx> extends Observable<ListrEvent> {
         title: string;
         output?: string;
-        task: (ctx: any, task: ListrTaskWrapper) => void | string | Promise<any> | stream.Readable | Listr | Observable<any>;
-        skip?: (ctx: any, task: ListrTaskWrapper) => boolean | Promise<boolean> | string | void | Observable<boolean>;
-        enabled?: (ctx: any, task: ListrTaskWrapper) => boolean | Promise<boolean> | Observable<boolean>;
+        task: (ctx: Ctx, task: ListrTaskWrapper<Ctx>) => void | ListrTaskResult<Ctx>;
+        skip: (ctx: Ctx) => void | boolean | string | Promise<boolean>;
+        subtasks: ReadonlyArray<ListrTaskWrapper<Ctx>>;
+        state: string;
+        check: (ctx: Ctx) => void;
+        hasSubtasks: boolean;
+        isPending: boolean;
+        isSkipped: boolean;
+        isCompleted: boolean;
+        isEnabled: boolean;
+        hasFailed: boolean;
+        run: (ctx: Ctx, wrapper: ListrTaskWrapper<Ctx>) => Promise<void>;
     }
 
-    interface ListrTaskWrapper {
+    interface ListrTaskWrapper<Ctx = ListrContext> {
         title: string;
-        output: any;
+        output: string;
         report(error: Error): void;
         skip(message: string): void;
-        run(ctx?: any): Promise<any>;
+        run(ctx?: Ctx): Promise<void>;
+    }
+
+    interface ListrError<Ctx> extends Error {
+        context: Ctx;
+    }
+
+    interface ListrRenderer {
+        render(): void;
+        end(err: Error): void;
+    }
+    interface ListrRendererClass<Ctx> {
+        nonTTY: boolean;
+        new(tasks: ReadonlyArray<ListrTaskObject<Ctx>>, options: ListrOptions<Ctx>): ListrRenderer;
     }
 }
 
-declare class Listr {
-    constructor(tasks?: ReadonlyArray<Listr.ListrTask>, options?: Listr.ListrOptions);
-    constructor(options?: Listr.ListrOptions);
-    add(tasks: Listr.ListrTask | ReadonlyArray<Listr.ListrTask>): void;
-    run(ctx?: any): Promise<any>;
+declare class Listr<Ctx = Listr.ListrContext> {
+    constructor(tasks?: ReadonlyArray<Listr.ListrTask<Ctx>>, options?: Listr.ListrOptions<Ctx>);
+    constructor(options?: Listr.ListrOptions<Ctx>);
+    tasks: ReadonlyArray<Listr.ListrTaskWrapper<Ctx>>;
+    setRenderer(value: Listr.ListrRendererValue<Ctx>): void;
+    add(tasks: Listr.ListrTask<Ctx> | ReadonlyArray<Listr.ListrTask<Ctx>>): void;
+    render(): void;
+    run(ctx?: Ctx): Promise<Ctx>;
 }
 
 export = Listr;

types/listr/listr-tests.ts

@@ -1,7 +1,12 @@
 import Listr = require("listr");
 import * as fs from "fs";
 
-const tasks = new Listr([
+interface Context {
+    foo: string;
+    yarn?: boolean;
+}
+
+const tasks = new Listr<Context>([
     {
         title: 'Git',
         task: () => {
@@ -165,3 +170,36 @@ tasks.run({
 }).then(ctx => {
     console.log(ctx);
 });
+
+class CustomRenderer {
+    constructor(tasks: ReadonlyArray<Listr.ListrTask<Context>>, options: Listr.ListrOptions<Context>) {}
+
+    static nonTTY = true;
+
+    render() {}
+    end(err: Listr.ListrError<Context>) {}
+}
+
+const tasks8 = new Listr<Context>(
+    [
+        {
+            title: 'Success',
+            task: () => 'Foo',
+        },
+    ],
+    {
+        renderer: CustomRenderer,
+    }
+);
+
+const tasks9 = new Listr(
+    [
+        {
+            title: 'Success',
+            task: () => 'Foo',
+        },
+    ],
+    {
+        renderer: 'default',
+    }
+);