Introduced TrackerResult.of(). Made other changes

src/core/session.ts

 import { Stats } from './stats';
 import { Gizmos } from '../ui/gizmos';
 import { Frame } from './frame';
-import { Tracker } from '../trackers/tracker';
+import { Trackable, Tracker, TrackerResult } from '../trackers/tracker';
 import { TimeManager } from './time-manager';
 import { Source } from '../sources/source';
 import { VideoSource } from '../sources/video-source';
     gizmos: false,
 };
 
+/** Helper class */
+class EmptyTrackerResult extends TrackerResult
+{
+    readonly tracker: Tracker;
+    readonly trackables: Trackable[];
+
+    constructor(tracker: Tracker)
+    {
+        super();
+        this.tracker = tracker;
+        this.trackables = [];
+    }
+}
+
+
 
 
 /**
 
                 // create a frame
                 const results = this._trackers.map(tracker =>
-                    tracker._output.exports || ({
-                        tracker: tracker,
-                        trackables: [],
-                    })
+                    tracker._output.exports || new EmptyTrackerResult(tracker)
                 );
                 const frame = new Frame(this, results);
 

src/sources/canvas-source.ts

      * A type-identifier of the source of data
      * @internal
      */
-    get _type(): string
+    get _type(): keyof SourceType
     {
         return 'canvas';
     }
 
     /**
      * 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]

src/sources/pointer-source.ts

      * A type-identifier of the source of data
      * @internal
      */
-    get _type(): string
+    get _type(): keyof SourceType
     {
         return 'pointer-source';
     }
 
     /**
      * 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]

src/sources/source.ts

 export interface Source
 {
     /** @internal type-identifier of the source of data */
-    readonly _type: string;
+    readonly _type: keyof SourceType;
 
-    /** @internal check if this source is of a certain type - this is a convenient type-narrowing utility */
+    /** @internal check if this source is of a certain type */
     _is<T extends keyof SourceType>(type: T): this is SourceType[T];
 
     /** @internal method to initialize the source of data (gets the data ready) */

src/sources/video-source.ts

      * A type-identifier of the source of data
      * @internal
      */
-    get _type(): string
+    get _type(): keyof SourceType
     {
         return 'video';
     }
 
     /**
      * 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]

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, TrackerType } from '../tracker';
+import { Tracker, TrackerOutput, TrackerResult, Trackable, TrackerType, TrackerResultType } from '../tracker';
 import { Session } from '../../core/session';
 import { IllegalOperationError, IllegalArgumentError } from '../../utils/errors';
 import { Resolution } from '../../utils/resolution';
 }
 
 /** Image Tracker result to be consumed by the user */
-export interface ImageTrackerResult extends TrackerResult
+export class ImageTrackerResult extends TrackerResult
 {
     /** tracker */
     readonly tracker: ImageTracker;
 
     /** 3D virtual camera */
     readonly viewer: Viewer;
+
+    /**
+     * Constructor
+     * @param tracker
+     * @param trackables
+     * @param viewer
+     */
+    constructor(tracker: ImageTracker, trackables: TrackableImage[], viewer: Viewer)
+    {
+        super();
+        this.tracker = tracker;
+        this.trackables = trackables;
+        this.viewer = viewer;
+    }
 }
 
 /** Image Tracker output */
 
     /**
      * 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]
     {

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

             };
 
             // the result generated by the image tracker
-            const result: ImageTrackerResult = {
-                tracker: this._imageTracker,
-                trackables: [ trackable ],
-                viewer: viewer
-            };
+            const result = new ImageTrackerResult(
+                this._imageTracker,
+                [ trackable ],
+                viewer
+            );
 
             // tracker output
             const trackerOutput: ImageTrackerOutput = {

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

 /**
  * A result of a PointerTracker. It's meant to be consumed by the user/application
  */
-export interface PointerTrackerResult extends TrackerResult
+export class PointerTrackerResult extends TrackerResult
 {
     /** the tracker that generated this result */
     readonly tracker: PointerTracker;
 
     /** the trackables */
     readonly trackables: TrackablePointer[];
+
+    /**
+     * Constructor
+     * @param tracker
+     * @param trackables
+     */
+    constructor(tracker: PointerTracker, trackables: TrackablePointer[])
+    {
+        super();
+        this.tracker = tracker;
+        this.trackables = trackables;
+    }
 }
 
 /**
 
     /**
      * 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]
     {
         const trackables: TrackablePointer[] = [];
         this._activePointers.forEach(trackable => trackables.push(trackable));
 
-        return {
-            exports: {
-                tracker: this,
-                trackables: this._sortTrackables(trackables)
-            }
-        };
+        const result = new PointerTrackerResult(this, this._sortTrackables(trackables));
+        return { exports: result };
     }
 
     /**

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';
+import { ImageTracker, ImageTrackerResult } from './image-tracker/image-tracker';
+import { PointerTracker, PointerTrackerResult } from './pointer-tracker/pointer-tracker';
 
 /**
  * A Trackable is something that can be tracked
  * The result of a Tracker in a particular frame of a session. Such result is
  * meant to be consumed by the user/application.
  */
-export interface TrackerResult
+export abstract class TrackerResult
 {
     /** the tracker that generated this result */
-    readonly tracker: Tracker;
+    abstract readonly tracker: Tracker;
 
     /** an array of trackables (possibly empty) */
-    readonly trackables: Trackable[];
+    abstract readonly trackables: Trackable[];
+
+    /** check if this result was generated by a tracker of a certain type */
+    of<T extends keyof TrackerResultType>(trackerType: T): this is TrackerResultType[T]
+    {
+        return this.tracker.is(trackerType);
+    }
 }
 
 /**
  */
 export interface Tracker
 {
-    /** check if this tracker is of a certain type - this is a convenient type-narrowing utility */
+    /** check if this tracker is of a certain type */
     is<T extends keyof TrackerType>(type: T): this is TrackerType[T];
 
     /** a string that identifies the type of the tracker @deprecated */
 export type TrackerType = {
     'image-tracker': ImageTracker,
     'pointer-tracker': PointerTracker
+};
+
+/**
+ * A helper for type-narrowing
+ * @internal
+ */
+export type TrackerResultType = {
+    'image-tracker': ImageTrackerResult,
+    'pointer-tracker': PointerTrackerResult
 };