Add functionality to capture type parameters in interfaces

src/transform-inline/visitor-utils.ts

@@ -138,6 +138,19 @@ export function getTypeReferenceMapping(type: ts.TypeReference, visitorContext:
         if (tsutils.isInterfaceType(type.target)) {
             const baseTypes = visitorContext.checker.getBaseTypes(type.target);
             for (const baseType of baseTypes) {
+                if (baseType.aliasTypeArguments && visitorContext.previousTypeReference !== baseType && (baseType as ts.TypeReference).target) {
+                    const typeReference = baseType as ts.TypeReference
+                    if (typeReference.aliasTypeArguments !== undefined && typeReference.target.aliasTypeArguments !== undefined) {
+                        const typeParameters = typeReference.target.aliasTypeArguments;
+                        const typeArguments = typeReference.aliasTypeArguments;
+                        for (let i = 0; i < typeParameters.length; i++) {
+                            if (typeParameters[i] !== typeArguments[i]) {
+                                mapping.set(typeParameters[i], typeArguments[i]);
+                            }
+                        }
+                    }
+                }
+
                 if (tsutils.isTypeReference(baseType) && baseType.target.typeParameters !== undefined && baseType.typeArguments !== undefined) {
                     const typeParameters = baseType.target.typeParameters;
                     const typeArguments = baseType.typeArguments;

test/issue-86.ts

@@ -0,0 +1,25 @@
+import * as assert from 'assert';
+import { is } from '../index';
+
+/* https://github.com/woutervh-/typescript-is/issues/86 */
+
+type Y<T> = {
+    field: T;
+}
+
+interface X extends Y<string> {
+}
+
+describe('is', () => {
+    describe('Interface extending a parameterised type alias', () => {
+        it('should return true for object with field type string', () => {
+            assert.deepStrictEqual(is<X>({ field: 'some-string' }), true);
+        });
+        it('should return false for object with field type number', () => {
+            assert.deepStrictEqual(is<X>({ field: 0 }), false);
+        });
+        it('should return false for object without field', () => {
+            assert.deepStrictEqual(is<X>({}), false);
+        });
+    });
+});