Introduce Tracker.is() for type-narrowing

demos/hello-three/demo.js

             return null;
 
         for(const result of ar.frame.results) {
-            if(result.tracker.type == 'image-tracker') {
+            if(result.tracker.is('image-tracker')) {
                 if(result.trackables.length > 0) {
                     const trackable = result.trackables[0];
                     return trackable.referenceImage.name;

demos/hello-world/demo.js

 function mix(frame)
 {
     for(const result of frame.results) {
-        if(result.tracker.type == 'image-tracker') {
+        if(result.tracker.is('image-tracker')) {
             if(result.trackables.length > 0) {
                 const trackable = result.trackables[0];
                 const projectionMatrix = result.viewer.view.projectionMatrix;

demos/pointer-demo/demo.js

 function read(frame)
 {
     for(const result of frame.results) {
-        if(result.tracker.type == 'pointer-tracker') {
+        if(result.tracker.is('pointer-tracker')) {
             const pointers = result.trackables;
             return pointers;
         }

docs/api/tracker.md

 
 An interface that represents a generic tracker. Trackers analyze input data in some way and are meant to be attached to a [session](session.md). Refer to the [concepts](../tutorial/concepts.md) for more information.
 
-An [Image Tracker](image-tracker.md) is an implementation of a tracker.
+An [Image Tracker](image-tracker.md) is an implementation of a tracker, and so is a [PointerTracker](pointer-tracker.md).
 
 ## Properties
 
 
 `tracker.type: string, read-only`
 
-A string representing the type of the tracker.
+A string representing the type of the tracker.
+
+*Deprecated since:* 0.4.4. Use `tracker.is()` instead.
+
+## Methods
+
+### is
+
+`tracker.is(type: string): boolean`
+
+Checks if `this` tracker is of a certain `type`. This works as a convenient type-narrowing method for TypeScript users.
+
+*Since:* 0.4.4
+
+**Returns**
+
+`true` if and only if `type === tracker.type`
+
+**Example**
+
+```ts
+let tracker: Tracker;
+
+// ...
+
+if(tracker.is('image-tracker')) {
+    // tracker is inferred to be an ImageTracker
+    // ...
+}
+else if(tracker.is('pointer-tracker')) {
+    // tracker is inferred to be a PointerTracker
+    // ...
+}
+else {
+    // ...
+}
+```

plugins/aframe-with-encantar.js

             return null;
 
         for(const result of frame.results) {
-            if(result.tracker.type == 'image-tracker') {
+            if(result.tracker.is('image-tracker')) {
                 for(const trackable of result.trackables) {
                     if(name === '' || name === trackable.referenceImage.name) {
                         return {
             return null;
 
         for(const result of frame.results) {
-            if(result.tracker.type == 'image-tracker') {
+            if(result.tracker.is('image-tracker')) {
                 if(result.trackables.length > 0)
                     return result.viewer;
             }
             return [];
 
         for(const result of frame.results) {
-            if(result.tracker.type == 'pointer-tracker')
+            if(result.tracker.is('pointer-tracker'))
                 return result.trackables;
         }
 

plugins/babylon-with-encantar.js

         ar._pointers.length = 0;
 
         for(const result of frame.results) {
-            if(result.tracker.type == 'image-tracker') {
+            if(result.tracker.is('image-tracker')) {
                 if(result.trackables.length > 0) {
                     const trackable = result.trackables[0];
                     const projectionMatrix = result.viewer.view.projectionMatrix;
                     found = true;
                 }
             }
-            else if(result.tracker.type == 'pointer-tracker') {
+            else if(result.tracker.is('pointer-tracker')) {
                 if(result.trackables.length > 0)
                     ar._pointers.push.apply(ar._pointers, result.trackables);
             }

plugins/three-with-encantar.js

         ar._pointers.length = 0;
 
         for(const result of frame.results) {
-            if(result.tracker.type == 'image-tracker') {
+            if(result.tracker.is('image-tracker')) {
                 if(result.trackables.length > 0) {
                     const trackable = result.trackables[0];
                     const projectionMatrix = result.viewer.view.projectionMatrix;
                     found = true;
                 }
             }
-            else if(result.tracker.type == 'pointer-tracker') {
+            else if(result.tracker.is('pointer-tracker')) {
                 if(result.trackables.length > 0)
                     ar._pointers.push.apply(ar._pointers, result.trackables);
             }

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

 import { SpeedyKeypoint } from 'speedy-vision/types/core/speedy-keypoint';
 import { VideoSource } from '../../sources/video-source';
 import { CanvasSource } from '../../sources/canvas-source';
-import { Tracker, TrackerOutput, TrackerResult, Trackable } from '../tracker';
+import { Tracker, TrackerOutput, TrackerResult, Trackable, TrackerType } from '../tracker';
 import { Session } from '../../core/session';
 import { IllegalOperationError, IllegalArgumentError } from '../../utils/errors';
 import { Resolution } from '../../utils/resolution';
 
     /**
      * The type of the tracker
+     * @deprecated
      */
-    get type(): string
+    get type(): keyof TrackerType
     {
         return 'image-tracker';
     }
 
     /**
+     * Check if this tracker is of a certain type
+     * This is a convenient type-narrowing utility
+     */
+    is<T extends keyof TrackerType>(type: T): this is TrackerType[T]
+    {
+        return type === this.type;
+    }
+
+    /**
      * Current state name
      */
     get state(): ImageTrackerStateName

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

 
 import Speedy from 'speedy-vision';
 import { SpeedyPromise } from 'speedy-vision/types/core/speedy-promise';
-import { TrackerResult, TrackerOutput, Tracker } from '../tracker';
+import { TrackerResult, TrackerOutput, Tracker, TrackerType } from '../tracker';
 import { TrackablePointer, TrackablePointerPhase } from './trackable-pointer';
 import { PointerSource } from '../../sources/pointer-source';
 import { Vector2 } from '../../geometry/vector2';
 
     /**
      * The type of the tracker
+     * @deprecated
      */
-    get type(): string
+    get type(): keyof TrackerType
     {
         return 'pointer-tracker';
     }
 
     /**
+     * Check if this tracker is of a certain type
+     * This is a convenient type-narrowing utility
+     */
+    is<T extends keyof TrackerType>(type: T): this is TrackerType[T]
+    {
+        return type === this.type;
+    }
+
+    /**
      * Initialize the tracker
      * @param session
      * @returns a promise that is resolved as soon as the tracker is initialized

src/trackers/tracker.ts

 import { Session } from '../core/session';
 import { SpeedyPromise } from 'speedy-vision/types/core/speedy-promise';
 import { SpeedyMedia } from 'speedy-vision/types/core/speedy-media';
+import { ImageTracker } from './image-tracker/image-tracker';
+import { PointerTracker } from './pointer-tracker/pointer-tracker';
 
 /**
  * A Trackable is something that can be tracked
  */
 export interface Tracker
 {
-    /** a string that identifies the type of the tracker */
-    readonly type: string;
+    /** check if this tracker is of a certain type - this is a convenient type-narrowing utility */
+    is<T extends keyof TrackerType>(type: T): this is TrackerType[T];
+
+    /** a string that identifies the type of the tracker @deprecated */
+    readonly type: keyof TrackerType;
 
     /** initialize tracker @internal */
-    _init: (session: Session) => SpeedyPromise<void>;
+    _init(session: Session): SpeedyPromise<void>;
 
     /** release resources @internal */
-    _release: () => SpeedyPromise<void>;
+    _release(): SpeedyPromise<void>;
 
     /** update cycle @internal */
-    _update: () => SpeedyPromise<void>;
+    _update(): SpeedyPromise<void>;
 
     /** output of the last frame @internal */
     readonly _output: TrackerOutput;
 
     /** stats related to this tracker @internal */
     readonly _stats: string;
-}
+}
+
+/**
+ * A helper for type-narrowing
+ * @internal
+ */
+export type TrackerType = {
+    'image-tracker': ImageTracker,
+    'pointer-tracker': PointerTracker
+};

src/ui/gizmos.ts

 
         // render the gizmos of each tracker
         for(let i = 0; i < trackers.length; i++) {
-            if(trackers[i].type == 'image-tracker') {
-                const output = trackers[i]._output as ImageTrackerOutput;
+            const tracker = trackers[i];
+            if(tracker.is('image-tracker')) {
+                const output = tracker._output;
                 this._imageTrackerGizmos.render(viewport, output);
             }
         }