Introduce Source._is() for type-narrowing

src/core/session.ts

     {
         // prefer video sources
         for(let i = 0; i < sources.length; i++) {
-            if(sources[i]._type == 'video')
-                return sources[i] as VideoSource;
+            const source = sources[i];
+            if(source._is('video'))
+                return source;
         }
         for(let i = 0; i < sources.length; i++) {
-            if(sources[i]._type == 'canvas')
-                return sources[i] as CanvasSource;
+            const source = sources[i];
+            if(source._is('canvas'))
+                return source;
         }
 
         // emit warning

src/sources/canvas-source.ts

 import { SpeedyPromise } from 'speedy-vision/types/core/speedy-promise';
 import { Utils, Nullable } from '../utils/utils';
 import { IllegalOperationError } from '../utils/errors';
-import { Source } from './source';
+import { Source, SourceType } from './source';
 
 /**
  * HTMLCanvasElement-based source of data
     }
 
     /**
+     * Check if this source is of a certain type
+     * This is a convenient type-narrowing utility
+     * @internal
+     */
+    _is<T extends keyof SourceType>(type: T): this is SourceType[T]
+    {
+        return type === this._type;
+    }
+
+    /**
      * Get media
      * @internal
      */

src/sources/pointer-source.ts

 
 import Speedy from 'speedy-vision';
 import { SpeedyPromise } from 'speedy-vision/types/core/speedy-promise';
-import { Source } from './source';
+import { Source, SourceType } from './source';
 import { Viewport } from '../core/viewport'
 import { Utils, Nullable } from '../utils/utils';
 
     }
 
     /**
+     * Check if this source is of a certain type
+     * This is a convenient type-narrowing utility
+     * @internal
+     */
+    _is<T extends keyof SourceType>(type: T): this is SourceType[T]
+    {
+        return type === this._type;
+    }
+
+    /**
      * Consume a pointer event
      * @returns the next pointer event to be consumed, or null if there are none
      * @internal

src/sources/source.ts

  */
 
 import { SpeedyPromise } from 'speedy-vision/types/core/speedy-promise';
+import { CanvasSource } from './canvas-source';
+import { PointerSource } from './pointer-source';
+import { VideoSource } from './video-source';
 
 /**
  * Abstract source of data
     /** @internal type-identifier of the source of data */
     readonly _type: string;
 
+    /** @internal check if this source is of a certain type - this is a convenient type-narrowing utility */
+    _is<T extends keyof SourceType>(type: T): this is SourceType[T];
+
     /** @internal method to initialize the source of data (gets the data ready) */
     _init(): SpeedyPromise<void>;
 
 
     /** @internal stats related to this source of data */
     readonly _stats: string;
-}
+}
+
+/**
+ * A helper for type-narrowing
+ * @internal
+ */
+export type SourceType = {
+    'video': VideoSource,
+    'canvas': CanvasSource,
+    'pointer-source': PointerSource
+};

src/sources/video-source.ts

 import { SpeedyPromise } from 'speedy-vision/types/core/speedy-promise';
 import { Utils, Nullable } from '../utils/utils';
 import { IllegalOperationError, NotSupportedError, TimeoutError } from '../utils/errors';
-import { Source } from './source';
+import { Source, SourceType } from './source';
 
 /** A message to be displayed if a video can't autoplay and user interaction is required */
 const ALERT_MESSAGE = 'Tap on the screen to start';
     }
 
     /**
+     * Check if this source is of a certain type
+     * This is a convenient type-narrowing utility
+     * @internal
+     */
+    _is<T extends keyof SourceType>(type: T): this is SourceType[T]
+    {
+        return type === this._type;
+    }
+
+    /**
      * Get media
      * @internal
      */

src/trackers/image-tracker/image-tracker.ts

         // XXX also let the user specify a source manually?
         for(const source of session.sources) {
             // prefer video sources
-            if(source._type == 'video') {
-                this._source = source as VideoSource;
+            if(source._is('video')) {
+                this._source = source;
                 break;
             }
-            else if(source._type == 'canvas')
-                this._source = source as CanvasSource;
+            else if(source._is('canvas'))
+                this._source = source;
         }
         if(this._source === null)
             throw new IllegalOperationError('The image tracker requires a suitable source of data');

src/trackers/pointer-tracker/pointer-tracker.ts

 
         // find the pointer source
         for(const source of session.sources) {
-            if(source._type == 'pointer-source') {
-                this._source = source as PointerSource;
+            if(source._is('pointer-source')) {
+                this._source = source;
                 break;
             }
         }