Fixed linting errors

vega · May 28, 2022 · 1658e10 · 1658e10
1 parent b186860
commit 1658e10
Show file tree

Hide file tree

Showing 4 changed files with 20 additions and 23 deletions.
diff --git a/src/NodeParser/ConditionalTypeNodeParser.ts b/src/NodeParser/ConditionalTypeNodeParser.ts
@@ -25,7 +25,7 @@ export class ConditionalTypeNodeParser implements SubNodeParser {
         }
 
         // Narrow down check type for both condition branches
-        let inferMap = new Map();
+        const inferMap = new Map();
         const trueCheckType = narrowType(checkType, (type) => isAssignableTo(extendsType, type, inferMap));
         const falseCheckType = narrowType(checkType, (type) => !isAssignableTo(extendsType, type));
 

diff --git a/src/TypeFormatter/TupleTypeFormatter.ts b/src/TypeFormatter/TupleTypeFormatter.ts
@@ -9,6 +9,21 @@ import { TypeFormatter } from "../TypeFormatter";
 import { notUndefined } from "../Utils/notUndefined";
 import { uniqueArray } from "../Utils/uniqueArray";
 
+function uniformRestType(type: RestType, check_type: BaseType): boolean {
+    const inner = type.getType();
+    return (
+        (inner instanceof ArrayType && inner.getItem().getId() === check_type.getId()) ||
+        (inner instanceof TupleType &&
+            inner.getTypes().every((tuple_type) => {
+                if (tuple_type instanceof RestType) {
+                    return uniformRestType(tuple_type, check_type);
+                } else {
+                    return tuple_type?.getId() === check_type.getId();
+                }
+            }))
+    );
+}
+
 export class TupleTypeFormatter implements SubTypeFormatter {
     public constructor(protected childTypeFormatter: TypeFormatter) {}
 
@@ -25,21 +40,6 @@ export class TupleTypeFormatter implements SubTypeFormatter {
         const restType = subTypes.find((t): t is RestType => t instanceof RestType);
         const firstItemType = requiredElements.length > 0 ? requiredElements[0] : optionalElements[0]?.getType();
 
-        function uniformRestType(type: RestType): boolean {
-            const inner = type.getType();
-            return (
-                (inner instanceof ArrayType && inner.getItem().getId() === firstItemType.getId()) ||
-                (inner instanceof TupleType &&
-                    inner.getTypes().every((tuple_type) => {
-                        if (tuple_type instanceof RestType) {
-                            return uniformRestType(tuple_type);
-                        } else {
-                            return tuple_type?.getId() === firstItemType.getId();
-                        }
-                    }))
-            );
-        }
-
         // Check whether the tuple is of any of the following forms:
         //   [A, A, A]
         //   [A, A, A?]
@@ -49,7 +49,7 @@ export class TupleTypeFormatter implements SubTypeFormatter {
             firstItemType &&
             requiredElements.every((item) => item.getId() === firstItemType.getId()) &&
             optionalElements.every((item) => item.getType().getId() === firstItemType.getId()) &&
-            (!restType || uniformRestType(restType));
+            (!restType || uniformRestType(restType, firstItemType));
 
         // If so, generate a simple array with minItems (and possibly maxItems) instead.
         if (isUniformArray) {

diff --git a/src/Utils/isAssignableTo.ts b/src/Utils/isAssignableTo.ts
@@ -108,8 +108,8 @@ export function isAssignableTo(
 
     // Infer type can become anything
     if (target instanceof InferType) {
-        let infer = inferMap.get(target.getName());
         const key = target.getName();
+        const infer = inferMap.get(key);
 
         if (infer === undefined) {
             inferMap.set(key, source);
@@ -262,7 +262,7 @@ export function isAssignableTo(
                 if (i == numTarget - 1) {
                     if (numTarget <= numSource + 1) {
                         if (targetMember instanceof RestType) {
-                            let remaining: Array<BaseType | undefined> = [];
+                            const remaining: Array<BaseType | undefined> = [];
                             for (let j = i; j < numSource; j++) {
                                 remaining.push(sourceMembers[j]);
                             }

diff --git a/test/unit/isAssignableTo.test.ts b/test/unit/isAssignableTo.test.ts
@@ -319,10 +319,7 @@ describe("isAssignableTo", () => {
             )
         ).toBe(true);
         expect(
-            isAssignableTo(
-                new TupleType([new StringType(), new InferType("T")]),
-                new TupleType([new StringType()])
-            )
+            isAssignableTo(new TupleType([new StringType(), new InferType("T")]), new TupleType([new StringType()]))
         ).toBe(false);
         expect(
             isAssignableTo(