From 5d455396d764f3ff4066b8fbe0c9767e30e03b56 Mon Sep 17 00:00:00 2001
From: Gerrit Birkeland <gerrit@gerritbirkeland.com>
Date: Sat, 1 May 2021 10:34:31 -0600
Subject: [PATCH] BREAKING CHANGE: Drop support for TypeScript 3.9

TypeDoc only supports the latest two TS minor releases to make development easier.
---
 package.json               |  2 +-
 src/lib/converter/types.ts | 61 +++++++++++++++++---------------------
 2 files changed, 28 insertions(+), 35 deletions(-)

diff --git a/package.json b/package.json
index 5c2dac385..33afde0be 100644
--- a/package.json
+++ b/package.json
@@ -30,7 +30,7 @@
     "typedoc-default-themes": "^0.12.10"
   },
   "peerDependencies": {
-    "typescript": "3.9.x || 4.0.x || 4.1.x || 4.2.x"
+    "typescript": "4.0.x || 4.1.x || 4.2.x"
   },
   "devDependencies": {
     "@types/lodash": "^4.14.168",
diff --git a/src/lib/converter/types.ts b/src/lib/converter/types.ts
index 2b77b610c..e07ec33b2 100644
--- a/src/lib/converter/types.ts
+++ b/src/lib/converter/types.ts
@@ -856,17 +856,13 @@ const thisConverter: TypeConverter<ts.ThisTypeNode> = {
 const tupleConverter: TypeConverter<ts.TupleTypeNode, ts.TupleTypeReference> = {
     kind: [ts.SyntaxKind.TupleType],
     convert(context, node) {
-        // TS 3.9 support
-        const elementTypes = node.elements ?? (node as any).elementTypes;
-        const elements = elementTypes.map((node) => convertType(context, node));
+        const elements = node.elements.map((node) =>
+            convertType(context, node)
+        );
         return new TupleType(elements);
     },
-    convertType(context, type, node) {
-        // TS 3.9 support
-        const elementTypes = node.elements ?? (node as any).elementTypes;
-        // We need to do this because of type argument constraints, see GH1449
-        // In TS 4.0 we could use type.target.fixedLength
-        const types = type.typeArguments?.slice(0, elementTypes.length);
+    convertType(context, type) {
+        const types = type.typeArguments?.slice(0, type.target.fixedLength);
         let elements = types?.map((type) => convertType(context, type));
 
         if (type.target.labeledElementDeclarations) {
@@ -881,34 +877,31 @@ const tupleConverter: TypeConverter<ts.TupleTypeNode, ts.TupleTypeReference> = {
             );
         }
 
-        // TS 3.9 support - always defined in 4.0
-        if (type.target.elementFlags) {
-            elements = elements?.map((el, i) => {
-                if (type.target.elementFlags[i] & ts.ElementFlags.Variable) {
-                    // In the node case, we don't need to add the wrapping Array type... but we do here.
-                    if (el instanceof NamedTupleMember) {
-                        return new RestType(
-                            new NamedTupleMember(
-                                el.name,
-                                el.isOptional,
-                                new ArrayType(el.element)
-                            )
-                        );
-                    }
-
-                    return new RestType(new ArrayType(el));
+        elements = elements?.map((el, i) => {
+            if (type.target.elementFlags[i] & ts.ElementFlags.Variable) {
+                // In the node case, we don't need to add the wrapping Array type... but we do here.
+                if (el instanceof NamedTupleMember) {
+                    return new RestType(
+                        new NamedTupleMember(
+                            el.name,
+                            el.isOptional,
+                            new ArrayType(el.element)
+                        )
+                    );
                 }
 
-                if (
-                    type.target.elementFlags[i] & ts.ElementFlags.Optional &&
-                    !(el instanceof NamedTupleMember)
-                ) {
-                    return new OptionalType(removeUndefined(el));
-                }
+                return new RestType(new ArrayType(el));
+            }
 
-                return el;
-            });
-        }
+            if (
+                type.target.elementFlags[i] & ts.ElementFlags.Optional &&
+                !(el instanceof NamedTupleMember)
+            ) {
+                return new OptionalType(removeUndefined(el));
+            }
+
+            return el;
+        });
 
         return new TupleType(elements ?? []);
     },