Added semantic versioning to track upgrades

Author: mikecentola

src/control.ts

@@ -5,15 +5,17 @@
 
 'use strict';
 
-import { Disposable, ExtensionContext } from 'vscode';
+import { commands, Disposable, ExtensionContext } from 'vscode';
 import { Config, configuration } from './util/config';
 import { Logger } from './util/logger';
 import { StatusBarControl } from './util/statusBar';
 import { NavTreeView } from './views/navTreeView';
 import { GCodeUnitsController } from './gcodeUnits';
 import { StatsView } from './views/statsView';
-import { PIcon } from './util/constants';
+import { constants, Contexts, GlobalState, PIcon, VSBuiltInCommands } from './util/constants';
 import { Commands } from './util/commands';
+import { LocalStorageService } from './util/localStorageService';
+import { Version } from './util/version';
 
 export class Control {
     private static _config: Config | undefined;
@@ -23,6 +25,7 @@ export class Control {
     // Controllers
     private static _statusBarControl: StatusBarControl;
     private static _unitsController: GCodeUnitsController | undefined;
+    private static _storageManager: LocalStorageService;
 
     // Views
     private static _statsView: StatsView | undefined;
@@ -32,6 +35,9 @@ export class Control {
         this._context = context;
         this._config = config;
 
+        // Load GlobalState Storage Manager
+        this._storageManager = new LocalStorageService(context);
+
         // Load StatusBars
         context.subscriptions.push((this._statusBarControl = new StatusBarControl(this._context)));
 
@@ -88,7 +94,7 @@ export class Control {
 
         // Load Support Heart to Statusbar
         this._statusBarControl.updateStatusBar(
-            PIcon.HEART,
+            PIcon.Heart,
             'support',
             'Support G-Code Syntax ❤',
             undefined,
@@ -108,6 +114,28 @@ export class Control {
         return secs * 1000 + nanosecs / 1000000;
     }
 
+    static checkVersion() {
+        const localVer = new Version(constants.extension.version);
+
+        const prevVer = this._storageManager.getValue<Version>(GlobalState.PreviousVersion, 'global') ?? localVer;
+
+        const newVer = localVer.compareWith(prevVer.getVersion()) === 1 ? true : false;
+
+        if (newVer) {
+            // Extension has been updated
+        } else {
+            return;
+        }
+    }
+
+    static showWhatsNew() {
+        // Show Whats New Message
+    }
+
+    static setContext(key: Contexts | string, value: any) {
+        return commands.executeCommand(VSBuiltInCommands.SetContext, key, value);
+    }
+
     static get context() {
         return this._context;
     }

src/util/version.ts

@@ -0,0 +1,79 @@
+/* ---------------------------------------------------------------------------------------------
+ *  Copyright (c) Applied Eng & Design All rights reserved.
+ *  Licensed under the MIT License. See License.md in the project root for license information.
+ * -------------------------------------------------------------------------------------------- */
+'use strict';
+
+export interface IVersion {
+    major: number;
+    minor: number;
+    patch: number;
+}
+
+export type VersionCheck = -1 | 0 | 1;
+
+export class Version {
+    private _version: IVersion;
+
+    constructor(ver: IVersion | string) {
+        if (typeof ver === 'string') {
+            this._version = this.parseVer(ver);
+        } else {
+            this._version = ver;
+        }
+    }
+
+    private parseVer(stringVer: string): IVersion {
+        const [major, minor, patch] = stringVer.split('.');
+        return {
+            major: parseInt(major, 10),
+            minor: parseInt(minor, 10),
+            patch: patch == null ? 0 : parseInt(patch, 10),
+        };
+    }
+
+    getVersion(): IVersion {
+        return this._version;
+    }
+
+    getVersionAsString(): string {
+        return `${this._version.major}.${this._version.minor}.${this._version.patch}`;
+    }
+
+    compareWith(ver: IVersion | string): VersionCheck {
+        // Compare Versions
+        if (typeof ver === 'string') {
+            ver = this.parseVer(ver);
+        }
+
+        // Check Major Version
+        if (this._version.major > ver.major) {
+            return 1;
+        }
+
+        if (this._version.major < ver.major) {
+            return -1;
+        }
+
+        // Check Minor Version
+        if (this._version.minor > ver.minor) {
+            return 1;
+        }
+
+        if (this._version.minor < ver.minor) {
+            return -1;
+        }
+
+        // Check Patch Version
+        if (this._version.patch > ver.patch) {
+            return 1;
+        }
+
+        if (this._version.patch < ver.patch) {
+            return -1;
+        }
+
+        // Versions are Equal
+        return 0;
+    }
+}