Committed as reference

catching any errors from a user canceling from dialog (#3968)
Fix navigation errors (#3970)
Only add listeners to observables on creation
Do not double destroy mutable objects
Disallow pause and play in time strip view for plots. (#3972)
Update version

Co-authored-by: Jamie V <jamie.j.vigliotta@nasa.gov>
Co-authored-by: Andrew Henry <akhenry@gmail.com>

index.html

@@ -194,6 +194,7 @@
             ['table', 'telemetry.plot.overlay', 'telemetry.plot.stacked'],
             {indicator: true}
         ));
+        openmct.install(openmct.plugins.CodeWalkthrough);
         openmct.start();
     </script>
 </html>

package.json

@@ -1,6 +1,6 @@
 {
   "name": "openmct",
-  "version": "1.7.4-SNAPSHOT",
+  "version": "1.7.4",
   "description": "The Open MCT core platform",
   "dependencies": {},
   "devDependencies": {

src/api/objects/ObjectAPI.js

@@ -399,25 +399,25 @@ ObjectAPI.prototype._toMutable = function (object) {
         mutableObject = object;
     } else {
         mutableObject = MutableDomainObject.createMutable(object, this.eventEmitter);
-    }
 
-    // Check if provider supports realtime updates
+        // Check if provider supports realtime updates
-    let identifier = utils.parseKeyString(mutableObject.identifier);
+        let identifier = utils.parseKeyString(mutableObject.identifier);
-    let provider = this.getProvider(identifier);
+        let provider = this.getProvider(identifier);
 
-    if (provider !== undefined
+        if (provider !== undefined
-        && provider.observe !== undefined
+            && provider.observe !== undefined
-        && this.SYNCHRONIZED_OBJECT_TYPES.includes(object.type)) {
+            && this.SYNCHRONIZED_OBJECT_TYPES.includes(object.type)) {
-        let unobserve = provider.observe(identifier, (updatedModel) => {
+            let unobserve = provider.observe(identifier, (updatedModel) => {
-            if (updatedModel.persisted > mutableObject.modified) {
+                if (updatedModel.persisted > mutableObject.modified) {
-                //Don't replace with a stale model. This can happen on slow connections when multiple mutations happen
+                    //Don't replace with a stale model. This can happen on slow connections when multiple mutations happen
-                //in rapid succession and intermediate persistence states are returned by the observe function.
+                    //in rapid succession and intermediate persistence states are returned by the observe function.
-                mutableObject.$refresh(updatedModel);
+                    mutableObject.$refresh(updatedModel);
-            }
+                }
-        });
+            });
-        mutableObject.$on('$_destroy', () => {
+            mutableObject.$on('$_destroy', () => {
-            unobserve();
+                unobserve();
-        });
+            });
+        }
     }
 
     return mutableObject;

src/plugins/codeWalkthrough/plugin.js

@@ -0,0 +1,71 @@
+import Vue from 'Vue';
+
+export default function install(openmct) {
+    openmct.objectViews.addProvider({
+        name: "Latest Data Table",
+        key: "latest-table",
+        cssClass: "icon-packet",
+        description: "A tabular view of telemetry contents.",
+        canView: function () {
+            return true;
+        },
+        view: function (domainObject) {
+            let unsubscribe;
+
+            return {
+                show: function (element) {
+                    //element.innerText = 'Hello World!';
+                    let telemetryMetadata = openmct.telemetry.getMetadata(domainObject).values();
+                    let tableEl = document.createElement('table');
+                    let tableHeader = document.createElement('thead');
+                    let tableHeaderRow = document.createElement('tr');
+                    let tableBody = document.createElement('tbody');
+
+                    element.appendChild(tableEl);
+                    tableHeader.appendChild(tableHeaderRow);
+                    tableEl.appendChild(tableHeader);
+                    tableEl.appendChild(tableBody);
+
+                    telemetryMetadata.forEach(metadatum => {
+                        let tableHeader = document.createElement('td');
+                        tableHeader.innerText = metadatum.name;
+                        tableHeaderRow.appendChild(tableHeader);
+                    });
+
+                    openmct.time.on('bounds', (newBounds) => {
+                        tableBody.innerHTML = '';
+                        requestTelemetry(newBounds);
+                    });
+
+                    requestTelemetry();
+
+                    // unsubscribe = openmct.telemetry.subscribe(domainObject, (datum) => {
+                    //     addRow(datum);
+                    // });
+
+                    function addRow(telemetryDatum) {
+                        let dataRow = document.createElement('tr');
+                        telemetryMetadata.forEach(metadatum => {
+                            let tableCell = document.createElement('td');
+                            let formatter = openmct.telemetry.getValueFormatter(metadatum);
+
+                            tableCell.innerText = formatter.format(telemetryDatum[metadatum.key]);
+                            dataRow.appendChild(tableCell);
+                            tableBody.appendChild(dataRow);
+                        });
+                    }
+
+                    function requestTelemetry(bounds) {
+                        openmct.telemetry.request(domainObject, {bounds}).then(arrayOfTelemetry => {
+                            arrayOfTelemetry.forEach(addRow);
+                        });
+                    }
+                },
+                destroy: function (element) {
+                    unsubscribe();
+                }
+            };
+        }
+    });
+
+}

src/plugins/duplicate/DuplicateAction.js

@@ -37,7 +37,15 @@ export default class DuplicateAction {
         let duplicationTask = new DuplicateTask(this.openmct);
         let originalObject = objectPath[0];
         let parent = objectPath[1];
-        let userInput = await this.getUserInput(originalObject, parent);
+        let userInput;
+
+        try {
+            userInput = await this.getUserInput(originalObject, parent);
+        } catch (error) {
+            // user most likely canceled
+            return;
+        }
+
         let newParent = userInput.location;
         let inNavigationPath = this.inNavigationPath(originalObject);
 

src/plugins/plot/MctPlot.vue

@@ -102,7 +102,7 @@
                         >
                         </button>
                     </div>
-                    <div v-if="isRealTime"
+                    <div v-if="isRealTime && !options.compact"
                          class="c-button-set c-button-set--strip-h js-pause"
                     >
                         <button v-if="!isFrozen"

src/plugins/plugins.js

@@ -65,7 +65,8 @@ define([
     './interceptors/plugin',
     './performanceIndicator/plugin',
     './CouchDBSearchFolder/plugin',
-    './timeline/plugin'
+    './timeline/plugin',
+    './codeWalkthrough/plugin'
 ], function (
     _,
     UTCTimeSystem,
@@ -111,7 +112,8 @@ define([
     ObjectInterceptors,
     PerformanceIndicator,
     CouchDBSearchFolder,
-    Timeline
+    Timeline,
+    codeWalkthroughPlugin
 ) {
     const bundleMap = {
         LocalStorage: 'platform/persistence/local',
@@ -212,6 +214,7 @@ define([
     plugins.PerformanceIndicator = PerformanceIndicator.default;
     plugins.CouchDBSearchFolder = CouchDBSearchFolder.default;
     plugins.Timeline = Timeline.default;
+    plugins.CodeWalkthrough = codeWalkthroughPlugin.default;
 
     return plugins;
 });

src/ui/router/Browse.js

@@ -10,7 +10,6 @@ define([
         let unobserve = undefined;
         let currentObjectPath;
         let isRoutingInProgress = false;
-        let mutable;
 
         openmct.router.route(/^\/browse\/?$/, navigateToFirstChildOfRoot);
         openmct.router.route(/^\/browse\/(.*)$/, (path, results, params) => {
@@ -37,24 +36,10 @@ define([
         }
 
         function viewObject(object, viewProvider) {
-            if (mutable) {
-                openmct.objects.destroyMutable(mutable);
-                mutable = undefined;
-            }
-
-            if (openmct.objects.supportsMutation(object.identifier)) {
-                mutable = openmct.objects._toMutable(object);
-            }
-
             currentObjectPath = openmct.router.path;
 
-            if (mutable !== undefined) {
+            openmct.layout.$refs.browseObject.show(object, viewProvider.key, true, currentObjectPath);
-                openmct.layout.$refs.browseObject.show(mutable, viewProvider.key, true, currentObjectPath);
+            openmct.layout.$refs.browseBar.domainObject = object;
-                openmct.layout.$refs.browseBar.domainObject = mutable;
-            } else {
-                openmct.layout.$refs.browseObject.show(object, viewProvider.key, true, currentObjectPath);
-                openmct.layout.$refs.browseBar.domainObject = object;
-            }
 
             openmct.layout.$refs.browseBar.viewKey = viewProvider.key;
         }