add install plugin tests

add no tabs test

CONTRIBUTING.md

@@ -182,7 +182,7 @@ The following guidelines are provided for anyone contributing source code to the
 1. Avoid the use of "magic" values.
    eg.
    ```JavaScript
-   const UNAUTHORIZED = 401;
+   Const UNAUTHORIZED = 401
    if (responseCode === UNAUTHORIZED)
    ```
    is preferable to

index.html

@@ -131,10 +131,10 @@
                         }
                     ],
                     // maximum recent bounds to retain in conductor history
-                    records: 10
+                    records: 10,
                     // maximum duration between start and end bounds
                     // for utc-based time systems this is in milliseconds
-                    // limit: ONE_DAY
+                    limit: ONE_DAY
                 },
                 {
                     name: "Realtime",

karma.conf.js

@@ -86,7 +86,7 @@ module.exports = (config) => {
             reports: ['html', 'lcovonly', 'text-summary'],
             thresholds: {
                 global: {
-                    lines: 66
+                    lines: 65
                 }
             }
         },

package.json

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

platform/commonUI/edit/src/policies/EditPersistableObjectsPolicy.js

@@ -44,9 +44,9 @@ define(
             // is also invoked during the create process which should be allowed,
             // because it may be saved elsewhere
             if ((key === 'edit' && category === 'view-control') || key === 'properties') {
-                let identifier = this.openmct.objects.parseKeyString(domainObject.getId());
+                let newStyleObject = objectUtils.toNewFormat(domainObject, domainObject.getId());
 
-                return this.openmct.objects.isPersistable(identifier);
+                return this.openmct.objects.isPersistable(newStyleObject);
             }
 
             return true;

platform/commonUI/edit/test/policies/EditPersistableObjectsSpec.js

@@ -43,8 +43,7 @@ define(
                 );
 
                 mockObjectAPI = jasmine.createSpyObj('objectAPI', [
-                    'isPersistable',
-                    'parseKeyString'
+                    'isPersistable'
                 ]);
 
                 mockAPI = {

platform/containment/src/PersistableCompositionPolicy.js

@@ -48,9 +48,9 @@ define(
             // prevents editing of objects that cannot be persisted, so we can assume that this
             // is a new object.
             if (!(parent.hasCapability('editor') && parent.getCapability('editor').isEditContextRoot())) {
-                let identifier = this.openmct.objects.parseKeyString(parent.getId());
+                let newStyleObject = objectUtils.toNewFormat(parent, parent.getId());
 
-                return this.openmct.objects.isPersistable(identifier);
+                return this.openmct.objects.isPersistable(newStyleObject);
             }
 
             return true;

platform/containment/test/PersistableCompositionPolicySpec.js

@@ -33,8 +33,7 @@ define(
 
             beforeEach(function () {
                 objectAPI = jasmine.createSpyObj('objectsAPI', [
-                    'isPersistable',
-                    'parseKeyString'
+                    'isPersistable'
                 ]);
 
                 mockOpenMCT = {

platform/search/src/services/BareBonesSearchWorker.js

@@ -32,8 +32,7 @@
     function indexItem(id, model) {
         indexedItems.push({
             id: id,
-            name: model.name.toLowerCase(),
-            type: model.type
+            name: model.name.toLowerCase()
         });
     }
 

platform/search/src/services/GenericSearchProvider.js

@@ -125,12 +125,13 @@ define([
      * @param topic the topicService.
      */
     GenericSearchProvider.prototype.indexOnMutation = function (topic) {
-        let mutationTopic = topic('mutation');
+        var mutationTopic = topic('mutation'),
+            provider = this;
 
-        mutationTopic.listen(mutatedObject => {
-            let editor = mutatedObject.getCapability('editor');
+        mutationTopic.listen(function (mutatedObject) {
+            var editor = mutatedObject.getCapability('editor');
             if (!editor || !editor.inEditContext()) {
-                this.index(
+                provider.index(
                     mutatedObject.getId(),
                     mutatedObject.getModel()
                 );
@@ -261,7 +262,6 @@ define([
                 return {
                     id: hit.item.id,
                     model: hit.item.model,
-                    type: hit.item.type,
                     score: hit.matchCount
                 };
             });

platform/search/src/services/GenericSearchWorker.js

@@ -41,8 +41,7 @@
         indexedItems.push({
             id: id,
             vector: vector,
-            model: model,
-            type: model.type
+            model: model
         });
     }
 

src/MCT.js

@@ -219,7 +219,7 @@ define([
          * @memberof module:openmct.MCT#
          * @name objects
          */
-        this.objects = new api.ObjectAPI.default(this.types);
+        this.objects = new api.ObjectAPI();
 
         /**
          * An interface for retrieving and interpreting telemetry data associated
@@ -371,7 +371,7 @@ define([
      *        MCT; if undefined, MCT will be run in the body of the document
      */
     MCT.prototype.start = function (domElement = document.body, isHeadlessMode = false) {
-        if (this.types.get('layout') === undefined) {
+        if (!this.plugins.DisplayLayout._installed) {
             this.install(this.plugins.DisplayLayout({
                 showAsView: ['summary-widget']
             }));

src/adapter/services/LegacyObjectAPIInterceptor.js

@@ -61,7 +61,6 @@ define([
             const newStyleObject = utils.toNewFormat(legacyObject.getModel(), legacyObject.getId());
             const keystring = utils.makeKeyString(newStyleObject.identifier);
 
-            this.eventEmitter.emit(keystring + ':$_synchronize_model', newStyleObject);
             this.eventEmitter.emit(keystring + ":*", newStyleObject);
             this.eventEmitter.emit('mutation', newStyleObject);
         }.bind(this);

src/api/actions/ActionCollectionSpec.js

@@ -1,229 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-
-import ActionCollection from './ActionCollection';
-import { createOpenMct, resetApplicationState } from '../../utils/testing';
-
-describe('The ActionCollection', () => {
-    let openmct;
-    let actionCollection;
-    let mockApplicableActions;
-    let mockObjectPath;
-    let mockView;
-
-    beforeEach(() => {
-        openmct = createOpenMct();
-        mockObjectPath = [
-            {
-                name: 'mock folder',
-                type: 'fake-folder',
-                identifier: {
-                    key: 'mock-folder',
-                    namespace: ''
-                }
-            },
-            {
-                name: 'mock parent folder',
-                type: 'fake-folder',
-                identifier: {
-                    key: 'mock-parent-folder',
-                    namespace: ''
-                }
-            }
-        ];
-        openmct.objects.addProvider('', jasmine.createSpyObj('mockMutableObjectProvider', [
-            'create',
-            'update'
-        ]));
-        mockView = {
-            getViewContext: () => {
-                return {
-                    onlyAppliesToTestCase: true
-                };
-            }
-        };
-        mockApplicableActions = {
-            'test-action-object-path': {
-                name: 'Test Action Object Path',
-                key: 'test-action-object-path',
-                cssClass: 'test-action-object-path',
-                description: 'This is a test action for object path',
-                group: 'action',
-                priority: 9,
-                appliesTo: (objectPath) => {
-                    if (objectPath.length) {
-                        return objectPath[0].type === 'fake-folder';
-                    }
-
-                    return false;
-                },
-                invoke: () => {
-                }
-            },
-            'test-action-view': {
-                name: 'Test Action View',
-                key: 'test-action-view',
-                cssClass: 'test-action-view',
-                description: 'This is a test action for view',
-                group: 'action',
-                priority: 9,
-                showInStatusBar: true,
-                appliesTo: (objectPath, view = {}) => {
-                    if (view.getViewContext) {
-                        let viewContext = view.getViewContext();
-
-                        return viewContext.onlyAppliesToTestCase;
-                    }
-
-                    return false;
-                },
-                invoke: () => {
-                }
-            }
-        };
-
-        actionCollection = new ActionCollection(mockApplicableActions, mockObjectPath, mockView, openmct);
-    });
-
-    afterEach(() => {
-        actionCollection.destroy();
-        resetApplicationState(openmct);
-    });
-
-    describe("disable method invoked with action keys", () => {
-        it("marks those actions as isDisabled", () => {
-            let actionKey = 'test-action-object-path';
-            let actionsObject = actionCollection.getActionsObject();
-            let action = actionsObject[actionKey];
-
-            expect(action.isDisabled).toBeFalsy();
-
-            actionCollection.disable([actionKey]);
-            actionsObject = actionCollection.getActionsObject();
-            action = actionsObject[actionKey];
-
-            expect(action.isDisabled).toBeTrue();
-        });
-    });
-
-    describe("enable method invoked with action keys", () => {
-        it("marks the isDisabled property as false", () => {
-            let actionKey = 'test-action-object-path';
-
-            actionCollection.disable([actionKey]);
-
-            let actionsObject = actionCollection.getActionsObject();
-            let action = actionsObject[actionKey];
-
-            expect(action.isDisabled).toBeTrue();
-
-            actionCollection.enable([actionKey]);
-            actionsObject = actionCollection.getActionsObject();
-            action = actionsObject[actionKey];
-
-            expect(action.isDisabled).toBeFalse();
-        });
-    });
-
-    describe("hide method invoked with action keys", () => {
-        it("marks those actions as isHidden", () => {
-            let actionKey = 'test-action-object-path';
-            let actionsObject = actionCollection.getActionsObject();
-            let action = actionsObject[actionKey];
-
-            expect(action.isHidden).toBeFalsy();
-
-            actionCollection.hide([actionKey]);
-            actionsObject = actionCollection.getActionsObject();
-            action = actionsObject[actionKey];
-
-            expect(action.isHidden).toBeTrue();
-        });
-    });
-
-    describe("show method invoked with action keys", () => {
-        it("marks the isHidden property as false", () => {
-            let actionKey = 'test-action-object-path';
-
-            actionCollection.hide([actionKey]);
-
-            let actionsObject = actionCollection.getActionsObject();
-            let action = actionsObject[actionKey];
-
-            expect(action.isHidden).toBeTrue();
-
-            actionCollection.show([actionKey]);
-            actionsObject = actionCollection.getActionsObject();
-            action = actionsObject[actionKey];
-
-            expect(action.isHidden).toBeFalse();
-        });
-    });
-
-    describe("getVisibleActions method", () => {
-        it("returns an array of non hidden actions", () => {
-            let action1Key = 'test-action-object-path';
-            let action2Key = 'test-action-view';
-
-            actionCollection.hide([action1Key]);
-
-            let visibleActions = actionCollection.getVisibleActions();
-
-            expect(Array.isArray(visibleActions)).toBeTrue();
-            expect(visibleActions.length).toEqual(1);
-            expect(visibleActions[0].key).toEqual(action2Key);
-
-            actionCollection.show([action1Key]);
-            visibleActions = actionCollection.getVisibleActions();
-
-            expect(visibleActions.length).toEqual(2);
-        });
-    });
-
-    describe("getStatusBarActions method", () => {
-        it("returns an array of non disabled, non hidden statusBar actions", () => {
-            let action2Key = 'test-action-view';
-
-            let statusBarActions = actionCollection.getStatusBarActions();
-
-            expect(Array.isArray(statusBarActions)).toBeTrue();
-            expect(statusBarActions.length).toEqual(1);
-            expect(statusBarActions[0].key).toEqual(action2Key);
-
-            actionCollection.disable([action2Key]);
-            statusBarActions = actionCollection.getStatusBarActions();
-
-            expect(statusBarActions.length).toEqual(0);
-
-            actionCollection.enable([action2Key]);
-            statusBarActions = actionCollection.getStatusBarActions();
-
-            expect(statusBarActions.length).toEqual(1);
-            expect(statusBarActions[0].key).toEqual(action2Key);
-
-            actionCollection.hide([action2Key]);
-            statusBarActions = actionCollection.getStatusBarActions();
-
-            expect(statusBarActions.length).toEqual(0);
-        });
-    });
-});

src/api/actions/ActionsAPISpec.js

@@ -22,41 +22,22 @@
 
 import ActionsAPI from './ActionsAPI';
 import { createOpenMct, resetApplicationState } from '../../utils/testing';
-import ActionCollection from './ActionCollection';
 
 describe('The Actions API', () => {
     let openmct;
     let actionsAPI;
     let mockAction;
     let mockObjectPath;
-    let mockObjectPathAction;
     let mockViewContext1;
 
     beforeEach(() => {
         openmct = createOpenMct();
         actionsAPI = new ActionsAPI(openmct);
-        mockObjectPathAction = {
-            name: 'Test Action Object Path',
-            key: 'test-action-object-path',
-            cssClass: 'test-action-object-path',
-            description: 'This is a test action for object path',
-            group: 'action',
-            priority: 9,
-            appliesTo: (objectPath) => {
-                if (objectPath.length) {
-                    return objectPath[0].type === 'fake-folder';
-                }
-
-                return false;
-            },
-            invoke: () => {
-            }
-        };
         mockAction = {
-            name: 'Test Action View',
-            key: 'test-action-view',
-            cssClass: 'test-action-view',
-            description: 'This is a test action for view',
+            name: 'Test Action',
+            key: 'test-action',
+            cssClass: 'test-action',
+            description: 'This is a test action',
             group: 'action',
             priority: 9,
             appliesTo: (objectPath, view = {}) => {
@@ -64,6 +45,8 @@ describe('The Actions API', () => {
                     let viewContext = view.getViewContext();
 
                     return viewContext.onlyAppliesToTestCase;
+                } else if (objectPath.length) {
+                    return objectPath[0].type === 'fake-folder';
                 }
 
                 return false;
@@ -117,32 +100,9 @@ describe('The Actions API', () => {
     describe("get method", () => {
         beforeEach(() => {
             actionsAPI.register(mockAction);
-            actionsAPI.register(mockObjectPathAction);
         });
 
-        it("returns an ActionCollection when invoked with an objectPath only", () => {
-            let actionCollection = actionsAPI.get(mockObjectPath);
-            let instanceOfActionCollection = actionCollection instanceof ActionCollection;
-
-            expect(instanceOfActionCollection).toBeTrue();
-        });
-
-        it("returns an ActionCollection when invoked with an objectPath and view", () => {
-            let actionCollection = actionsAPI.get(mockObjectPath, mockViewContext1);
-            let instanceOfActionCollection = actionCollection instanceof ActionCollection;
-
-            expect(instanceOfActionCollection).toBeTrue();
-        });
-
-        it("returns relevant actions when invoked with objectPath only", () => {
-            let actionCollection = actionsAPI.get(mockObjectPath);
-            let action = actionCollection.getActionsObject()[mockObjectPathAction.key];
-
-            expect(action.key).toEqual(mockObjectPathAction.key);
-            expect(action.name).toEqual(mockObjectPathAction.name);
-        });
-
-        it("returns relevant actions when invoked with objectPath and view", () => {
+        it("returns an object with relevant actions when invoked with objectPath only", () => {
             let actionCollection = actionsAPI.get(mockObjectPath, mockViewContext1);
             let action = actionCollection.getActionsObject()[mockAction.key];
 

src/api/composition/CompositionCollection.js

@@ -60,17 +60,6 @@ define([
         };
         this.onProviderAdd = this.onProviderAdd.bind(this);
         this.onProviderRemove = this.onProviderRemove.bind(this);
-        this.mutables = {};
-
-        if (this.domainObject.isMutable) {
-            this.returnMutables = true;
-            let unobserve = this.domainObject.$on('$_destroy', () => {
-                Object.values(this.mutables).forEach(mutable => {
-                    this.publicAPI.objects.destroyMutable(mutable);
-                });
-                unobserve();
-            });
-        }
     }
 
     /**
@@ -86,6 +75,10 @@ define([
             throw new Error('Event not supported by composition: ' + event);
         }
 
+        if (!this.mutationListener) {
+            this._synchronize();
+        }
+
         if (this.provider.on && this.provider.off) {
             if (event === 'add') {
                 this.provider.on(
@@ -196,13 +189,6 @@ define([
 
             this.provider.add(this.domainObject, child.identifier);
         } else {
-            if (this.returnMutables && this.publicAPI.objects.supportsMutation(child)) {
-                let keyString = this.publicAPI.objects.makeKeyString(child.identifier);
-
-                child = this.publicAPI.objects._toMutable(child);
-                this.mutables[keyString] = child;
-            }
-
             this.emit('add', child);
         }
     };
@@ -216,8 +202,6 @@ define([
      * @name load
      */
     CompositionCollection.prototype.load = function () {
-        this.cleanUpMutables();
-
         return this.provider.load(this.domainObject)
             .then(function (children) {
                 return Promise.all(children.map((c) => this.publicAPI.objects.get(c)));
@@ -250,14 +234,6 @@ define([
         if (!skipMutate) {
             this.provider.remove(this.domainObject, child.identifier);
         } else {
-            if (this.returnMutables) {
-                let keyString = this.publicAPI.objects.makeKeyString(child);
-                if (this.mutables[keyString] !== undefined && this.mutables[keyString].isMutable) {
-                    this.publicAPI.objects.destroyMutable(this.mutables[keyString]);
-                    delete this.mutables[keyString];
-                }
-            }
-
             this.emit('remove', child);
         }
     };
@@ -305,6 +281,12 @@ define([
         this.remove(child, true);
     };
 
+    CompositionCollection.prototype._synchronize = function () {
+        this.mutationListener = this.publicAPI.objects.observe(this.domainObject, '*', (newDomainObject) => {
+            this.domainObject = JSON.parse(JSON.stringify(newDomainObject));
+        });
+    };
+
     CompositionCollection.prototype._destroy = function () {
         if (this.mutationListener) {
             this.mutationListener();
@@ -326,11 +308,5 @@ define([
         });
     };
 
-    CompositionCollection.prototype.cleanUpMutables = function () {
-        Object.values(this.mutables).forEach(mutable => {
-            this.publicAPI.objects.destroyMutable(mutable);
-        });
-    };
-
     return CompositionCollection;
 });

src/api/menu/MenuAPI.js

@@ -38,7 +38,7 @@ class MenuAPI {
         this._showObjectMenu = this._showObjectMenu.bind(this);
     }
 
-    showMenu(x, y, actions, onDestroy) {
+    showMenu(x, y, actions) {
         if (this.menuComponent) {
             this.menuComponent.dismiss();
         }
@@ -46,8 +46,7 @@ class MenuAPI {
         let options = {
             x,
             y,
-            actions,
-            onDestroy
+            actions
         };
 
         this.menuComponent = new Menu(options);

src/api/menu/MenuAPISpec.js

@@ -31,7 +31,6 @@ describe ('The Menu API', () => {
     let x;
     let y;
     let result;
-    let onDestroy;
 
     beforeEach(() => {
         openmct = createOpenMct();
@@ -74,9 +73,7 @@ describe ('The Menu API', () => {
             let vueComponent;
 
             beforeEach(() => {
-                onDestroy = jasmine.createSpy('onDestroy');
-
-                menuAPI.showMenu(x, y, actionsArray, onDestroy);
+                menuAPI.showMenu(x, y, actionsArray);
                 vueComponent = menuAPI.menuComponent.component;
                 menuComponent = document.querySelector(".c-menu");
 
@@ -123,12 +120,6 @@ describe ('The Menu API', () => {
 
                 expect(vueComponent.$destroy).toHaveBeenCalled();
             });
-
-            it("invokes the onDestroy callback if passed in", () => {
-                document.body.click();
-
-                expect(onDestroy).toHaveBeenCalled();
-            });
         });
     });
 });

src/api/notifications/NotificationAPISpec.js

@@ -1,154 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-
-import NotificationAPI from './NotificationAPI';
-
-describe('The Notifiation API', () => {
-    let notificationAPIInstance;
-    let defaultTimeout = 4000;
-
-    beforeAll(() => {
-        notificationAPIInstance = new NotificationAPI();
-    });
-
-    describe('the info method', () => {
-        let message = 'Example Notification Message';
-        let severity = 'info';
-        let notificationModel;
-
-        beforeAll(() => {
-            notificationModel = notificationAPIInstance.info(message).model;
-        });
-
-        afterAll(() => {
-            notificationAPIInstance.dismissAllNotifications();
-        });
-
-        it('shows a string message with info severity', () => {
-            expect(notificationModel.message).toEqual(message);
-            expect(notificationModel.severity).toEqual(severity);
-        });
-
-        it('auto dismisses the notification after a brief timeout', (done) => {
-            window.setTimeout(() => {
-                expect(notificationAPIInstance.notifications.length).toEqual(0);
-                done();
-            }, defaultTimeout);
-        });
-    });
-
-    describe('the alert method', () => {
-        let message = 'Example alert message';
-        let severity = 'alert';
-        let notificationModel;
-
-        beforeAll(() => {
-            notificationModel = notificationAPIInstance.alert(message).model;
-        });
-
-        afterAll(() => {
-            notificationAPIInstance.dismissAllNotifications();
-        });
-
-        it('shows a string message, with alert severity', () => {
-            expect(notificationModel.message).toEqual(message);
-            expect(notificationModel.severity).toEqual(severity);
-        });
-
-        it('does not auto dismiss the notification', (done) => {
-            window.setTimeout(() => {
-                expect(notificationAPIInstance.notifications.length).toEqual(1);
-                done();
-            }, defaultTimeout);
-        });
-    });
-
-    describe('the error method', () => {
-        let message = 'Example error message';
-        let severity = 'error';
-        let notificationModel;
-
-        beforeAll(() => {
-            notificationModel = notificationAPIInstance.error(message).model;
-        });
-
-        afterAll(() => {
-            notificationAPIInstance.dismissAllNotifications();
-        });
-
-        it('shows a string message, with severity error', () => {
-            expect(notificationModel.message).toEqual(message);
-            expect(notificationModel.severity).toEqual(severity);
-        });
-
-        it('does not auto dismiss the notification', (done) => {
-            window.setTimeout(() => {
-                expect(notificationAPIInstance.notifications.length).toEqual(1);
-                done();
-            }, defaultTimeout);
-        });
-    });
-
-    describe('the progress method', () => {
-        let title = 'This is a progress notification';
-        let message1 = 'Example progress message 1';
-        let message2 = 'Example progress message 2';
-        let percentage1 = 50;
-        let percentage2 = 99.9;
-        let severity = 'info';
-        let notification;
-        let updatedPercentage;
-        let updatedMessage;
-
-        beforeAll(() => {
-            notification = notificationAPIInstance.progress(title, percentage1, message1);
-            notification.on('progress', (percentage, text) => {
-                updatedPercentage = percentage;
-                updatedMessage = text;
-            });
-        });
-
-        afterAll(() => {
-            notificationAPIInstance.dismissAllNotifications();
-        });
-
-        it ('shows a notification with a message, progress message, percentage and info severity', () => {
-            expect(notification.model.message).toEqual(title);
-            expect(notification.model.severity).toEqual(severity);
-            expect(notification.model.progressText).toEqual(message1);
-            expect(notification.model.progressPerc).toEqual(percentage1);
-        });
-
-        it ('allows dynamically updating the progress attributes', () => {
-            notification.progress(percentage2, message2);
-
-            expect(updatedPercentage).toEqual(percentage2);
-            expect(updatedMessage).toEqual(message2);
-        });
-
-        it ('allows dynamically dismissing of progress notification', () => {
-            notification.dismiss();
-
-            expect(notificationAPIInstance.notifications.length).toEqual(0);
-        });
-    });
-});

src/api/objects/MutableDomainObject.js

@@ -1,137 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-import _ from 'lodash';
-import utils from './object-utils.js';
-import EventEmitter from 'EventEmitter';
-
-const ANY_OBJECT_EVENT = 'mutation';
-
-/**
- * Wraps a domain object to keep its model synchronized with other instances of the same object.
- *
- * Creating a MutableDomainObject will automatically register listeners to keep its model in sync. As such, developers
- * should be careful to destroy MutableDomainObject in order to avoid memory leaks.
- *
- * All Open MCT API functions that provide objects will provide MutableDomainObjects where possible, except
- * `openmct.objects.get()`, and will manage that object's lifecycle for you. Calling `openmct.objects.getMutable()`
- * will result in the creation of a new MutableDomainObject and you will be responsible for destroying it
- * (via openmct.objects.destroy) when you're done with it.
- *
- * @typedef MutableDomainObject
- * @memberof module:openmct
- */
-class MutableDomainObject {
-    constructor(eventEmitter) {
-        Object.defineProperties(this, {
-            _globalEventEmitter: {
-                value: eventEmitter,
-                // Property should not be serialized
-                enumerable: false
-            },
-            _instanceEventEmitter: {
-                value: new EventEmitter(),
-                // Property should not be serialized
-                enumerable: false
-            },
-            _observers: {
-                value: [],
-                // Property should not be serialized
-                enumerable: false
-            },
-            isMutable: {
-                value: true,
-                // Property should not be serialized
-                enumerable: false
-            }
-        });
-    }
-    $observe(path, callback) {
-        let fullPath = qualifiedEventName(this, path);
-        let eventOff =
-            this._globalEventEmitter.off.bind(this._globalEventEmitter, fullPath, callback);
-
-        this._globalEventEmitter.on(fullPath, callback);
-        this._observers.push(eventOff);
-
-        return eventOff;
-    }
-    $set(path, value) {
-        _.set(this, path, value);
-        _.set(this, 'modified', Date.now());
-
-        //Emit secret synchronization event first, so that all objects are in sync before subsequent events fired.
-        this._globalEventEmitter.emit(qualifiedEventName(this, '$_synchronize_model'), this);
-
-        //Emit a general "any object" event
-        this._globalEventEmitter.emit(ANY_OBJECT_EVENT, this);
-        //Emit wildcard event, with path so that callback knows what changed
-        this._globalEventEmitter.emit(qualifiedEventName(this, '*'), this, path, value);
-
-        //Emit events specific to properties affected
-        let parentPropertiesList = path.split('.');
-        for (let index = parentPropertiesList.length; index > 0; index--) {
-            let parentPropertyPath = parentPropertiesList.slice(0, index).join('.');
-            this._globalEventEmitter.emit(qualifiedEventName(this, parentPropertyPath), _.get(this, parentPropertyPath));
-        }
-
-        //TODO: Emit events for listeners of child properties when parent changes.
-        // Do it at observer time - also register observers for parent attribute path.
-    }
-    $on(event, callback) {
-        this._instanceEventEmitter.on(event, callback);
-
-        return () => this._instanceEventEmitter.off(event, callback);
-    }
-    $destroy() {
-        this._observers.forEach(observer => observer());
-        delete this._globalEventEmitter;
-        delete this._observers;
-        this._instanceEventEmitter.emit('$_destroy');
-    }
-
-    static createMutable(object, mutationTopic) {
-        let mutable = Object.create(new MutableDomainObject(mutationTopic));
-        Object.assign(mutable, object);
-
-        mutable.$observe('$_synchronize_model', (updatedObject) => {
-            let clone = JSON.parse(JSON.stringify(updatedObject));
-            let deleted = _.difference(Object.keys(mutable), Object.keys(updatedObject));
-            deleted.forEach((propertyName) => delete mutable[propertyName]);
-            Object.assign(mutable, clone);
-        });
-
-        return mutable;
-    }
-
-    static mutateObject(object, path, value) {
-        _.set(object, path, value);
-        _.set(object, 'modified', Date.now());
-    }
-}
-
-function qualifiedEventName(object, eventName) {
-    let keystring = utils.makeKeyString(object.identifier);
-
-    return [keystring, eventName].join(':');
-}
-
-export default MutableDomainObject;

src/api/objects/MutableObject.js

@@ -0,0 +1,102 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2020, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+
+define([
+    'objectUtils',
+    'lodash'
+], function (
+    utils,
+    _
+) {
+    const ANY_OBJECT_EVENT = "mutation";
+
+    /**
+     * The MutableObject wraps a DomainObject and provides getters and
+     * setters for
+     * @param eventEmitter
+     * @param object
+     * @interface MutableObject
+     */
+    function MutableObject(eventEmitter, object) {
+        this.eventEmitter = eventEmitter;
+        this.object = object;
+        this.unlisteners = [];
+    }
+
+    function qualifiedEventName(object, eventName) {
+        const keystring = utils.makeKeyString(object.identifier);
+
+        return [keystring, eventName].join(':');
+    }
+
+    MutableObject.prototype.stopListening = function () {
+        this.unlisteners.forEach(function (unlisten) {
+            unlisten();
+        });
+        this.unlisteners = [];
+    };
+
+    /**
+     * Observe changes to this domain object.
+     * @param {string} path the property to observe
+     * @param {Function} callback a callback to invoke when new values for
+     *        this property are observed
+     * @method on
+     * @memberof module:openmct.MutableObject#
+     */
+    MutableObject.prototype.on = function (path, callback) {
+        const fullPath = qualifiedEventName(this.object, path);
+        const eventOff =
+            this.eventEmitter.off.bind(this.eventEmitter, fullPath, callback);
+
+        this.eventEmitter.on(fullPath, callback);
+        this.unlisteners.push(eventOff);
+    };
+
+    /**
+     * Modify this domain object.
+     * @param {string} path the property to modify
+     * @param {*} value the new value for this property
+     * @method set
+     * @memberof module:openmct.MutableObject#
+     */
+    MutableObject.prototype.set = function (path, value) {
+        _.set(this.object, path, value);
+        _.set(this.object, 'modified', Date.now());
+
+        const handleRecursiveMutation = function (newObject) {
+            this.object = newObject;
+        }.bind(this);
+
+        //Emit wildcard event
+        this.eventEmitter.emit(qualifiedEventName(this.object, '*'), this.object);
+        //Emit a general "any object" event
+        this.eventEmitter.emit(ANY_OBJECT_EVENT, this.object);
+
+        this.eventEmitter.on(qualifiedEventName(this.object, '*'), handleRecursiveMutation);
+        //Emit event specific to property
+        this.eventEmitter.emit(qualifiedEventName(this.object, path), value);
+        this.eventEmitter.off(qualifiedEventName(this.object, '*'), handleRecursiveMutation);
+    };
+
+    return MutableObject;
+});

src/api/objects/ObjectAPI.js

@@ -20,425 +20,365 @@
  * at runtime from the About dialog for additional information.
  *****************************************************************************/
 
-import utils from 'objectUtils';
-import MutableDomainObject from './MutableDomainObject';
-import RootRegistry from './RootRegistry';
-import RootObjectProvider from './RootObjectProvider';
-import EventEmitter from 'EventEmitter';
-import InterceptorRegistry from './InterceptorRegistry';
+define([
+    'lodash',
+    'objectUtils',
+    './MutableObject',
+    './RootRegistry',
+    './RootObjectProvider',
+    './InterceptorRegistry',
+    'EventEmitter'
+], function (
+    _,
+    utils,
+    MutableObject,
+    RootRegistry,
+    RootObjectProvider,
+    InterceptorRegistry,
+    EventEmitter
+) {
 
-/**
- * Utilities for loading, saving, and manipulating domain objects.
- * @interface ObjectAPI
- * @memberof module:openmct
- */
+    /**
+     * Utilities for loading, saving, and manipulating domain objects.
+     * @interface ObjectAPI
+     * @memberof module:openmct
+     */
 
-function ObjectAPI(typeRegistry) {
-    this.typeRegistry = typeRegistry;
-    this.eventEmitter = new EventEmitter();
-    this.providers = {};
-    this.rootRegistry = new RootRegistry();
-    this.rootProvider = new RootObjectProvider(this.rootRegistry);
-    this.cache = {};
-    this.interceptorRegistry = new InterceptorRegistry();
-}
-
-/**
- * Set fallback provider, this is an internal API for legacy reasons.
- * @private
- */
-ObjectAPI.prototype.supersecretSetFallbackProvider = function (p) {
-    this.fallbackProvider = p;
-};
-
-/**
- * Retrieve the provider for a given identifier.
- * @private
- */
-ObjectAPI.prototype.getProvider = function (identifier) {
-    if (identifier.key === 'ROOT') {
-        return this.rootProvider;
+    function ObjectAPI() {
+        this.eventEmitter = new EventEmitter();
+        this.providers = {};
+        this.rootRegistry = new RootRegistry();
+        this.rootProvider = new RootObjectProvider.default(this.rootRegistry);
+        this.cache = {};
+        this.interceptorRegistry = new InterceptorRegistry.default();
     }
 
-    return this.providers[identifier.namespace] || this.fallbackProvider;
-};
+    /**
+     * Set fallback provider, this is an internal API for legacy reasons.
+     * @private
+     */
+    ObjectAPI.prototype.supersecretSetFallbackProvider = function (p) {
+        this.fallbackProvider = p;
+    };
 
-/**
- * Get the root-level object.
- * @returns {Promise.<DomainObject>} a promise for the root object
- */
-ObjectAPI.prototype.getRoot = function () {
-    return this.rootProvider.get();
-};
+    /**
+     * Retrieve the provider for a given identifier.
+     * @private
+     */
+    ObjectAPI.prototype.getProvider = function (identifier) {
+        if (identifier.key === 'ROOT') {
+            return this.rootProvider;
+        }
 
-/**
- * Register a new object provider for a particular namespace.
- *
- * @param {string} namespace the namespace for which to provide objects
- * @param {module:openmct.ObjectProvider} provider the provider which
- *        will handle loading domain objects from this namespace
- * @memberof {module:openmct.ObjectAPI#}
- * @name addProvider
- */
-ObjectAPI.prototype.addProvider = function (namespace, provider) {
-    this.providers[namespace] = provider;
-};
+        return this.providers[identifier.namespace] || this.fallbackProvider;
+    };
 
-/**
- * Provides the ability to read, write, and delete domain objects.
- *
- * When registering a new object provider, all methods on this interface
- * are optional.
- *
- * @interface ObjectProvider
- * @memberof module:openmct
- */
+    /**
+     * Get the root-level object.
+     * @returns {Promise.<DomainObject>} a promise for the root object
+     */
+    ObjectAPI.prototype.getRoot = function () {
+        return this.rootProvider.get();
+    };
 
-/**
- * Create the given domain object in the corresponding persistence store
- *
- * @method create
- * @memberof module:openmct.ObjectProvider#
- * @param {module:openmct.DomainObject} domainObject the domain object to
- *        create
- * @returns {Promise} a promise which will resolve when the domain object
- *          has been created, or be rejected if it cannot be saved
- */
+    /**
+     * Register a new object provider for a particular namespace.
+     *
+     * @param {string} namespace the namespace for which to provide objects
+     * @param {module:openmct.ObjectProvider} provider the provider which
+     *        will handle loading domain objects from this namespace
+     * @memberof {module:openmct.ObjectAPI#}
+     * @name addProvider
+     */
+    ObjectAPI.prototype.addProvider = function (namespace, provider) {
+        this.providers[namespace] = provider;
+    };
 
-/**
- * Update this domain object in its persistence store
- *
- * @method update
- * @memberof module:openmct.ObjectProvider#
- * @param {module:openmct.DomainObject} domainObject the domain object to
- *        update
- * @returns {Promise} a promise which will resolve when the domain object
- *          has been updated, or be rejected if it cannot be saved
- */
+    /**
+     * Provides the ability to read, write, and delete domain objects.
+     *
+     * When registering a new object provider, all methods on this interface
+     * are optional.
+     *
+     * @interface ObjectProvider
+     * @memberof module:openmct
+     */
 
-/**
- * Delete this domain object.
- *
- * @method delete
- * @memberof module:openmct.ObjectProvider#
- * @param {module:openmct.DomainObject} domainObject the domain object to
- *        delete
- * @returns {Promise} a promise which will resolve when the domain object
- *          has been deleted, or be rejected if it cannot be deleted
- */
+    /**
+     * Create the given domain object in the corresponding persistence store
+     *
+     * @method create
+     * @memberof module:openmct.ObjectProvider#
+     * @param {module:openmct.DomainObject} domainObject the domain object to
+     *        create
+     * @returns {Promise} a promise which will resolve when the domain object
+     *          has been created, or be rejected if it cannot be saved
+     */
 
-/**
- * Get a domain object.
- *
- * @method get
- * @memberof module:openmct.ObjectProvider#
- * @param {string} key the key for the domain object to load
- * @returns {Promise} a promise which will resolve when the domain object
- *          has been saved, or be rejected if it cannot be saved
- */
+    /**
+     * Update this domain object in its persistence store
+     *
+     * @method update
+     * @memberof module:openmct.ObjectProvider#
+     * @param {module:openmct.DomainObject} domainObject the domain object to
+     *        update
+     * @returns {Promise} a promise which will resolve when the domain object
+     *          has been updated, or be rejected if it cannot be saved
+     */
 
-ObjectAPI.prototype.get = function (identifier) {
-    let keystring = this.makeKeyString(identifier);
-    if (this.cache[keystring] !== undefined) {
-        return this.cache[keystring];
-    }
+    /**
+     * Delete this domain object.
+     *
+     * @method delete
+     * @memberof module:openmct.ObjectProvider#
+     * @param {module:openmct.DomainObject} domainObject the domain object to
+     *        delete
+     * @returns {Promise} a promise which will resolve when the domain object
+     *          has been deleted, or be rejected if it cannot be deleted
+     */
 
-    identifier = utils.parseKeyString(identifier);
-    const provider = this.getProvider(identifier);
+    /**
+     * Get a domain object.
+     *
+     * @method get
+     * @memberof module:openmct.ObjectProvider#
+     * @param {string} key the key for the domain object to load
+     * @returns {Promise} a promise which will resolve when the domain object
+     *          has been saved, or be rejected if it cannot be saved
+     */
 
-    if (!provider) {
-        throw new Error('No Provider Matched');
-    }
+    /**
+     * Get a domain object.
+     *
+     * @method get
+     * @memberof module:openmct.ObjectAPI#
+     * @param {module:openmct.ObjectAPI~Identifier} identifier
+     *        the identifier for the domain object to load
+     * @returns {Promise} a promise which will resolve when the domain object
+     *          has been saved, or be rejected if it cannot be saved
+     */
+    ObjectAPI.prototype.get = function (identifier) {
+        let keystring = this.makeKeyString(identifier);
+        if (this.cache[keystring] !== undefined) {
+            return this.cache[keystring];
+        }
 
-    if (!provider.get) {
-        throw new Error('Provider does not support get!');
-    }
+        identifier = utils.parseKeyString(identifier);
+        const provider = this.getProvider(identifier);
 
-    let objectPromise = provider.get(identifier);
-    this.cache[keystring] = objectPromise;
+        if (!provider) {
+            throw new Error('No Provider Matched');
+        }
 
-    return objectPromise.then(result => {
-        delete this.cache[keystring];
-        const interceptors = this.listGetInterceptors(identifier, result);
-        interceptors.forEach(interceptor => {
-            result = interceptor.invoke(identifier, result);
+        if (!provider.get) {
+            throw new Error('Provider does not support get!');
+        }
+
+        let objectPromise = provider.get(identifier);
+
+        this.cache[keystring] = objectPromise;
+
+        return objectPromise.then(result => {
+            delete this.cache[keystring];
+            const interceptors = this.listGetInterceptors(identifier, result);
+            interceptors.forEach(interceptor => {
+                result = interceptor.invoke(identifier, result);
+            });
+
+            return result;
         });
+    };
+
+    ObjectAPI.prototype.delete = function () {
+        throw new Error('Delete not implemented');
+    };
+
+    ObjectAPI.prototype.isPersistable = function (domainObject) {
+        let provider = this.getProvider(domainObject.identifier);
+
+        return provider !== undefined
+            && provider.create !== undefined
+            && provider.update !== undefined;
+    };
+
+    /**
+     * Save this domain object in its current state. EXPERIMENTAL
+     *
+     * @private
+     * @memberof module:openmct.ObjectAPI#
+     * @param {module:openmct.DomainObject} domainObject the domain object to
+     *        save
+     * @returns {Promise} a promise which will resolve when the domain object
+     *          has been saved, or be rejected if it cannot be saved
+     */
+    ObjectAPI.prototype.save = function (domainObject) {
+        let provider = this.getProvider(domainObject.identifier);
+        let savedResolve;
+        let result;
+
+        if (!this.isPersistable(domainObject)) {
+            result = Promise.reject('Object provider does not support saving');
+        } else if (hasAlreadyBeenPersisted(domainObject)) {
+            result = Promise.resolve(true);
+        } else {
+            const persistedTime = Date.now();
+            if (domainObject.persisted === undefined) {
+                result = new Promise((resolve) => {
+                    savedResolve = resolve;
+                });
+                domainObject.persisted = persistedTime;
+                provider.create(domainObject).then((response) => {
+                    this.mutate(domainObject, 'persisted', persistedTime);
+                    savedResolve(response);
+                });
+            } else {
+                domainObject.persisted = persistedTime;
+                this.mutate(domainObject, 'persisted', persistedTime);
+                result = provider.update(domainObject);
+            }
+        }
 
         return result;
-    });
-};
+    };
 
-/**
- * Will fetch object for the given identifier, returning a version of the object that will automatically keep
- * itself updated as it is mutated. Before using this function, you should ask yourself whether you really need it.
- * The platform will provide mutable objects to views automatically if the underlying object can be mutated. The
- * platform will manage the lifecycle of any mutable objects that it provides. If you use `getMutable` you are
- * committing to managing that lifecycle yourself. `.destroy` should be called when the object is no longer needed.
- *
- * @memberof {module:openmct.ObjectAPI#}
- * @returns {Promise.<MutableDomainObject>} a promise that will resolve with a MutableDomainObject if
- * the object can be mutated.
- */
-ObjectAPI.prototype.getMutable = function (identifier) {
-    if (!this.supportsMutation(identifier)) {
-        throw new Error(`Object "${this.makeKeyString(identifier)}" does not support mutation.`);
-    }
+    /**
+     * Add a root-level object.
+     * @param {module:openmct.ObjectAPI~Identifier|function} an array of
+     *        identifiers for root level objects, or a function that returns a
+     *        promise for an identifier or an array of root level objects.
+     * @method addRoot
+     * @memberof module:openmct.ObjectAPI#
+     */
+    ObjectAPI.prototype.addRoot = function (key) {
+        this.rootRegistry.addRoot(key);
+    };
 
-    return this.get(identifier).then((object) => {
-        return this._toMutable(object);
-    });
-};
+    /**
+     * Modify a domain object.
+     * @param {module:openmct.DomainObject} object the object to mutate
+     * @param {string} path the property to modify
+     * @param {*} value the new value for this property
+     * @method mutate
+     * @memberof module:openmct.ObjectAPI#
+     */
+    ObjectAPI.prototype.mutate = function (domainObject, path, value) {
+        const mutableObject =
+            new MutableObject(this.eventEmitter, domainObject);
 
-/**
- * This function is for cleaning up a mutable domain object when you're done with it.
- * You only need to use this if you retrieved the object using `getMutable()`. If the object was provided by the
- * platform (eg. passed into a `view()` function) then the platform is responsible for its lifecycle.
- * @param {MutableDomainObject} domainObject
- */
-ObjectAPI.prototype.destroyMutable = function (domainObject) {
-    if (domainObject.isMutable) {
-        return domainObject.$destroy();
-    } else {
-        throw new Error("Attempted to destroy non-mutable domain object");
-    }
-};
+        return mutableObject.set(path, value);
+    };
 
-ObjectAPI.prototype.delete = function () {
-    throw new Error('Delete not implemented');
-};
+    /**
+     * Observe changes to a domain object.
+     * @param {module:openmct.DomainObject} object the object to observe
+     * @param {string} path the property to observe
+     * @param {Function} callback a callback to invoke when new values for
+     *        this property are observed
+     * @method observe
+     * @memberof module:openmct.ObjectAPI#
+     */
+    ObjectAPI.prototype.observe = function (domainObject, path, callback) {
+        const mutableObject =
+            new MutableObject(this.eventEmitter, domainObject);
+        mutableObject.on(path, callback);
 
-ObjectAPI.prototype.isPersistable = function (idOrKeyString) {
-    let identifier = utils.parseKeyString(idOrKeyString);
-    let provider = this.getProvider(identifier);
+        return mutableObject.stopListening.bind(mutableObject);
+    };
 
-    return provider !== undefined
-        && provider.create !== undefined
-        && provider.update !== undefined;
-};
+    /**
+     * @param {module:openmct.ObjectAPI~Identifier} identifier
+     * @returns {string} A string representation of the given identifier, including namespace and key
+     */
+    ObjectAPI.prototype.makeKeyString = function (identifier) {
+        return utils.makeKeyString(identifier);
+    };
 
-/**
- * Save this domain object in its current state. EXPERIMENTAL
- *
- * @private
- * @memberof module:openmct.ObjectAPI#
- * @param {module:openmct.DomainObject} domainObject the domain object to
- *        save
- * @returns {Promise} a promise which will resolve when the domain object
- *          has been saved, or be rejected if it cannot be saved
- */
-ObjectAPI.prototype.save = function (domainObject) {
-    let provider = this.getProvider(domainObject.identifier);
-    let savedResolve;
-    let result;
-
-    if (!this.isPersistable(domainObject.identifier)) {
-        result = Promise.reject('Object provider does not support saving');
-    } else if (hasAlreadyBeenPersisted(domainObject)) {
-        result = Promise.resolve(true);
-    } else {
-        const persistedTime = Date.now();
-        if (domainObject.persisted === undefined) {
-            result = new Promise((resolve) => {
-                savedResolve = resolve;
+    /**
+     * Given any number of identifiers, will return true if they are all equal, otherwise false.
+     * @param {module:openmct.ObjectAPI~Identifier[]} identifiers
+     */
+    ObjectAPI.prototype.areIdsEqual = function (...identifiers) {
+        return identifiers.map(utils.parseKeyString)
+            .every(identifier => {
+                return identifier === identifiers[0]
+                    || (identifier.namespace === identifiers[0].namespace
+                        && identifier.key === identifiers[0].key);
             });
-            domainObject.persisted = persistedTime;
-            provider.create(domainObject).then((response) => {
-                this.mutate(domainObject, 'persisted', persistedTime);
-                savedResolve(response);
-            });
-        } else {
-            domainObject.persisted = persistedTime;
-            this.mutate(domainObject, 'persisted', persistedTime);
-            result = provider.update(domainObject);
-        }
-    }
+    };
 
-    return result;
-};
+    ObjectAPI.prototype.getOriginalPath = function (identifier, path = []) {
+        return this.get(identifier).then((domainObject) => {
+            path.push(domainObject);
+            let location = domainObject.location;
 
-/**
- * Add a root-level object.
- * @param {module:openmct.ObjectAPI~Identifier|function} an array of
- *        identifiers for root level objects, or a function that returns a
- *        promise for an identifier or an array of root level objects.
- * @method addRoot
- * @memberof module:openmct.ObjectAPI#
- */
-ObjectAPI.prototype.addRoot = function (key) {
-    this.rootRegistry.addRoot(key);
-};
-
-/**
- * Register an object interceptor that transforms a domain object requested via module:openmct.ObjectAPI.get
- * The domain object will be transformed after it is retrieved from the persistence store
- * The domain object will be transformed only if the interceptor is applicable to that domain object as defined by the InterceptorDef
- *
- * @param {module:openmct.InterceptorDef} interceptorDef the interceptor definition to add
- * @method addGetInterceptor
- * @memberof module:openmct.InterceptorRegistry#
- */
-ObjectAPI.prototype.addGetInterceptor = function (interceptorDef) {
-    this.interceptorRegistry.addInterceptor(interceptorDef);
-};
-
-/**
- * Retrieve the interceptors for a given domain object.
- * @private
- */
-ObjectAPI.prototype.listGetInterceptors = function (identifier, object) {
-    return this.interceptorRegistry.getInterceptors(identifier, object);
-};
-
-/**
- * Modify a domain object.
- * @param {module:openmct.DomainObject} object the object to mutate
- * @param {string} path the property to modify
- * @param {*} value the new value for this property
- * @method mutate
- * @memberof module:openmct.ObjectAPI#
- */
-ObjectAPI.prototype.mutate = function (domainObject, path, value) {
-    if (!this.supportsMutation(domainObject.identifier)) {
-        throw `Error: Attempted to mutate immutable object ${domainObject.name}`;
-    }
-
-    if (domainObject.isMutable) {
-        domainObject.$set(path, value);
-    } else {
-        //Creating a temporary mutable domain object allows other mutable instances of the
-        //object to be kept in sync.
-        let mutableDomainObject = this._toMutable(domainObject);
-
-        //Mutate original object
-        MutableDomainObject.mutateObject(domainObject, path, value);
-
-        //Mutate temporary mutable object, in the process informing any other mutable instances
-        mutableDomainObject.$set(path, value);
-
-        //Destroy temporary mutable object
-        this.destroyMutable(mutableDomainObject);
-    }
-};
-
-/**
- * @private
- */
-ObjectAPI.prototype._toMutable = function (object) {
-    if (object.isMutable) {
-        return object;
-    } else {
-        return MutableDomainObject.createMutable(object, this.eventEmitter);
-    }
-};
-
-/**
- * @param module:openmct.ObjectAPI~Identifier identifier An object identifier
- * @returns {boolean} true if the object can be mutated, otherwise returns false
- */
-ObjectAPI.prototype.supportsMutation = function (identifier) {
-    return this.isPersistable(identifier);
-};
-
-/**
- * Observe changes to a domain object.
- * @param {module:openmct.DomainObject} object the object to observe
- * @param {string} path the property to observe
- * @param {Function} callback a callback to invoke when new values for
- *        this property are observed
- * @method observe
- * @memberof module:openmct.ObjectAPI#
- */
-ObjectAPI.prototype.observe = function (domainObject, path, callback) {
-    if (domainObject.isMutable) {
-        return domainObject.$observe(path, callback);
-    } else {
-        let mutable = this._toMutable(domainObject);
-        mutable.$observe(path, callback);
-
-        return () => mutable.$destroy();
-    }
-};
-
-/**
- * @param {module:openmct.ObjectAPI~Identifier} identifier
- * @returns {string} A string representation of the given identifier, including namespace and key
- */
-ObjectAPI.prototype.makeKeyString = function (identifier) {
-    return utils.makeKeyString(identifier);
-};
-
-/**
- * @param {string} keyString A string representation of the given identifier, that is, a namespace and key separated by a colon.
- * @returns {module:openmct.ObjectAPI~Identifier} An identifier object
- */
-ObjectAPI.prototype.parseKeyString = function (keyString) {
-    return utils.parseKeyString(keyString);
-};
-
-/**
- * Given any number of identifiers, will return true if they are all equal, otherwise false.
- * @param {module:openmct.ObjectAPI~Identifier[]} identifiers
- */
-ObjectAPI.prototype.areIdsEqual = function (...identifiers) {
-    return identifiers.map(utils.parseKeyString)
-        .every(identifier => {
-            return identifier === identifiers[0]
-                || (identifier.namespace === identifiers[0].namespace
-                    && identifier.key === identifiers[0].key);
+            if (location) {
+                return this.getOriginalPath(utils.parseKeyString(location), path);
+            } else {
+                return path;
+            }
         });
-};
+    };
 
-ObjectAPI.prototype.getOriginalPath = function (identifier, path = []) {
-    return this.get(identifier).then((domainObject) => {
-        path.push(domainObject);
-        let location = domainObject.location;
+    /**
+     * Register an object interceptor that transforms a domain object requested via module:openmct.ObjectAPI.get
+     * The domain object will be transformed after it is retrieved from the persistence store
+     * The domain object will be transformed only if the interceptor is applicable to that domain object as defined by the InterceptorDef
+     *
+     * @param {module:openmct.InterceptorDef} interceptorDef the interceptor definition to add
+     * @method addGetInterceptor
+     * @memberof module:openmct.InterceptorRegistry#
+     */
+    ObjectAPI.prototype.addGetInterceptor = function (interceptorDef) {
+        this.interceptorRegistry.addInterceptor(interceptorDef);
+    };
 
-        if (location) {
-            return this.getOriginalPath(utils.parseKeyString(location), path);
-        } else {
-            return path;
-        }
-    });
-};
+    /**
+     * Retrieve the interceptors for a given domain object.
+     * @private
+     */
+    ObjectAPI.prototype.listGetInterceptors = function (identifier, object) {
+        return this.interceptorRegistry.getInterceptors(identifier, object);
+    };
 
-/**
- * Uniquely identifies a domain object.
- *
- * @typedef Identifier
- * @memberof module:openmct.ObjectAPI~
- * @property {string} namespace the namespace to/from which this domain
- *           object should be loaded/stored.
- * @property {string} key a unique identifier for the domain object
- *           within that namespace
- */
+    /**
+     * Uniquely identifies a domain object.
+     *
+     * @typedef Identifier
+     * @memberof module:openmct.ObjectAPI~
+     * @property {string} namespace the namespace to/from which this domain
+     *           object should be loaded/stored.
+     * @property {string} key a unique identifier for the domain object
+     *           within that namespace
+     */
 
-/**
- * A domain object is an entity of relevance to a user's workflow, that
- * should appear as a distinct and meaningful object within the user
- * interface. Examples of domain objects are folders, telemetry sensors,
- * and so forth.
- *
- * A few common properties are defined for domain objects. Beyond these,
- * individual types of domain objects may add more as they see fit.
- *
- * @property {module:openmct.ObjectAPI~Identifier} identifier a key/namespace pair which
- *           uniquely identifies this domain object
- * @property {string} type the type of domain object
- * @property {string} name the human-readable name for this domain object
- * @property {string} [creator] the user name of the creator of this domain
- *           object
- * @property {number} [modified] the time, in milliseconds since the UNIX
- *           epoch, at which this domain object was last modified
- * @property {module:openmct.ObjectAPI~Identifier[]} [composition] if
- *           present, this will be used by the default composition provider
- *           to load domain objects
- * @typedef DomainObject
- * @memberof module:openmct
- */
+    /**
+     * A domain object is an entity of relevance to a user's workflow, that
+     * should appear as a distinct and meaningful object within the user
+     * interface. Examples of domain objects are folders, telemetry sensors,
+     * and so forth.
+     *
+     * A few common properties are defined for domain objects. Beyond these,
+     * individual types of domain objects may add more as they see fit.
+     *
+     * @property {module:openmct.ObjectAPI~Identifier} identifier a key/namespace pair which
+     *           uniquely identifies this domain object
+     * @property {string} type the type of domain object
+     * @property {string} name the human-readable name for this domain object
+     * @property {string} [creator] the user name of the creator of this domain
+     *           object
+     * @property {number} [modified] the time, in milliseconds since the UNIX
+     *           epoch, at which this domain object was last modified
+     * @property {module:openmct.ObjectAPI~Identifier[]} [composition] if
+     *           present, this will be used by the default composition provider
+     *           to load domain objects
+     * @typedef DomainObject
+     * @memberof module:openmct
+     */
 
-function hasAlreadyBeenPersisted(domainObject) {
-    return domainObject.persisted !== undefined
-        && domainObject.persisted === domainObject.modified;
-}
+    function hasAlreadyBeenPersisted(domainObject) {
+        return domainObject.persisted !== undefined
+            && domainObject.persisted === domainObject.modified;
+    }
 
-export default ObjectAPI;
+    return ObjectAPI;
+});

src/api/objects/ObjectAPISpec.js

@@ -2,16 +2,12 @@ import ObjectAPI from './ObjectAPI.js';
 
 describe("The Object API", () => {
     let objectAPI;
-    let typeRegistry;
     let mockDomainObject;
     const TEST_NAMESPACE = "test-namespace";
     const FIFTEEN_MINUTES = 15 * 60 * 1000;
 
     beforeEach(() => {
-        typeRegistry = jasmine.createSpyObj('typeRegistry', [
-            'get'
-        ]);
-        objectAPI = new ObjectAPI(typeRegistry);
+        objectAPI = new ObjectAPI();
         mockDomainObject = {
             identifier: {
                 namespace: TEST_NAMESPACE,
@@ -37,7 +33,6 @@ describe("The Object API", () => {
                     "update"
                 ]);
                 mockProvider.create.and.returnValue(Promise.resolve(true));
-                mockProvider.update.and.returnValue(Promise.resolve(true));
                 objectAPI.addProvider(TEST_NAMESPACE, mockProvider);
             });
             it("Calls 'create' on provider if object is new", () => {
@@ -133,131 +128,4 @@ describe("The Object API", () => {
             });
         });
     });
-
-    describe("the mutation API", () => {
-        let testObject;
-        let mutable;
-        let mockProvider;
-
-        beforeEach(function () {
-            objectAPI = new ObjectAPI(typeRegistry);
-            testObject = {
-                identifier: {
-                    namespace: TEST_NAMESPACE,
-                    key: 'test-key'
-                },
-                name: 'test object',
-                otherAttribute: 'other-attribute-value',
-                objectAttribute: {
-                    embeddedObject: {
-                        embeddedKey: 'embedded-value'
-                    }
-                }
-            };
-            mockProvider = jasmine.createSpyObj("mock provider", [
-                "get",
-                "create",
-                "update"
-            ]);
-            mockProvider.get.and.returnValue(Promise.resolve(testObject));
-            objectAPI.addProvider(TEST_NAMESPACE, mockProvider);
-
-            return objectAPI.getMutable(testObject.identifier)
-                .then(object => {
-                    mutable = object;
-
-                    return mutable;
-                });
-        });
-
-        afterEach(() => {
-            mutable.$destroy();
-        });
-
-        it('mutates the original object', () => {
-            const MUTATED_NAME = 'mutated name';
-            objectAPI.mutate(testObject, 'name', MUTATED_NAME);
-            expect(testObject.name).toBe(MUTATED_NAME);
-        });
-
-        describe ('uses a MutableDomainObject', () => {
-            it('and retains properties of original object ', function () {
-                expect(hasOwnProperty(mutable, 'identifier')).toBe(true);
-                expect(hasOwnProperty(mutable, 'otherAttribute')).toBe(true);
-                expect(mutable.identifier).toEqual(testObject.identifier);
-                expect(mutable.otherAttribute).toEqual(testObject.otherAttribute);
-            });
-
-            it('that is identical to original object when serialized', function () {
-                expect(JSON.stringify(mutable)).toEqual(JSON.stringify(testObject));
-            });
-        });
-
-        describe('uses events', function () {
-            let testObjectDuplicate;
-            let mutableSecondInstance;
-
-            beforeEach(function () {
-                // Duplicate object to guarantee we are not sharing object instance, which would invalidate test
-                testObjectDuplicate = JSON.parse(JSON.stringify(testObject));
-                mutableSecondInstance = objectAPI._toMutable(testObjectDuplicate);
-            });
-
-            afterEach(() => {
-                mutableSecondInstance.$destroy();
-            });
-
-            it('to stay synchronized when mutated', function () {
-                objectAPI.mutate(mutable, 'otherAttribute', 'new-attribute-value');
-                expect(mutableSecondInstance.otherAttribute).toBe('new-attribute-value');
-            });
-
-            it('to indicate when a property changes', function () {
-                let mutationCallback = jasmine.createSpy('mutation-callback');
-                let unlisten;
-
-                return new Promise(function (resolve) {
-                    mutationCallback.and.callFake(resolve);
-                    unlisten = objectAPI.observe(mutableSecondInstance, 'otherAttribute', mutationCallback);
-                    objectAPI.mutate(mutable, 'otherAttribute', 'some-new-value');
-                }).then(function () {
-                    expect(mutationCallback).toHaveBeenCalledWith('some-new-value');
-                    unlisten();
-                });
-            });
-
-            it('to indicate when a child property has changed', function () {
-                let embeddedKeyCallback = jasmine.createSpy('embeddedKeyCallback');
-                let embeddedObjectCallback = jasmine.createSpy('embeddedObjectCallback');
-                let objectAttributeCallback = jasmine.createSpy('objectAttribute');
-                let listeners = [];
-
-                return new Promise(function (resolve) {
-                    objectAttributeCallback.and.callFake(resolve);
-
-                    listeners.push(objectAPI.observe(mutableSecondInstance, 'objectAttribute.embeddedObject.embeddedKey', embeddedKeyCallback));
-                    listeners.push(objectAPI.observe(mutableSecondInstance, 'objectAttribute.embeddedObject', embeddedObjectCallback));
-                    listeners.push(objectAPI.observe(mutableSecondInstance, 'objectAttribute', objectAttributeCallback));
-
-                    objectAPI.mutate(mutable, 'objectAttribute.embeddedObject.embeddedKey', 'updated-embedded-value');
-                }).then(function () {
-                    expect(embeddedKeyCallback).toHaveBeenCalledWith('updated-embedded-value');
-                    expect(embeddedObjectCallback).toHaveBeenCalledWith({
-                        embeddedKey: 'updated-embedded-value'
-                    });
-                    expect(objectAttributeCallback).toHaveBeenCalledWith({
-                        embeddedObject: {
-                            embeddedKey: 'updated-embedded-value'
-                        }
-                    });
-
-                    listeners.forEach(listener => listener());
-                });
-            });
-        });
-    });
 });
-
-function hasOwnProperty(object, property) {
-    return Object.prototype.hasOwnProperty.call(object, property);
-}

src/plugins/LADTable/LADTableViewProvider.js

@@ -43,16 +43,12 @@ export default function LADTableViewProvider(openmct) {
                         components: {
                             LadTableComponent: LadTable
                         },
-                        data: () => {
-                            return {
-                                domainObject,
-                                objectPath
-                            };
-                        },
                         provide: {
-                            openmct
+                            openmct,
+                            domainObject,
+                            objectPath
                         },
-                        template: '<lad-table-component :domain-object="domainObject" :object-path="objectPath"></lad-table-component>'
+                        template: '<lad-table-component></lad-table-component>'
                     });
                 },
                 destroy: function (element) {

src/plugins/LADTable/components/LADRow.vue

@@ -26,7 +26,7 @@
     class="js-lad-table__body__row"
     @contextmenu.prevent="showContextMenu"
 >
-    <td class="js-first-data">{{ domainObject.name }}</td>
+    <td class="js-first-data">{{ name }}</td>
     <td class="js-second-data">{{ formattedTimestamp }}</td>
     <td
         class="js-third-data"
@@ -50,16 +50,12 @@ const CONTEXT_MENU_ACTIONS = [
 ];
 
 export default {
-    inject: ['openmct'],
+    inject: ['openmct', 'objectPath'],
     props: {
         domainObject: {
             type: Object,
             required: true
         },
-        objectPath: {
-            type: Array,
-            required: true
-        },
         hasUnits: {
             type: Boolean,
             requred: true
@@ -70,6 +66,7 @@ export default {
         currentObjectPath.unshift(this.domainObject);
 
         return {
+            name: this.domainObject.name,
             timestamp: undefined,
             value: '---',
             valueClass: '',
@@ -92,6 +89,14 @@ export default {
             .telemetry
             .limitEvaluator(this.domainObject);
 
+        this.stopWatchingMutation = this.openmct
+            .objects
+            .observe(
+                this.domainObject,
+                '*',
+                this.updateName
+            );
+
         this.openmct.time.on('timeSystem', this.updateTimeSystem);
         this.openmct.time.on('bounds', this.updateBounds);
 
@@ -114,6 +119,7 @@ export default {
         }
     },
     destroyed() {
+        this.stopWatchingMutation();
         this.unsubscribe();
         this.openmct.time.off('timeSystem', this.updateTimeSystem);
         this.openmct.time.off('bounds', this.updateBounds);
@@ -154,6 +160,9 @@ export default {
                 })
                 .then((array) => this.updateValues(array[array.length - 1]));
         },
+        updateName(name) {
+            this.name = name;
+        },
         updateBounds(bounds, isTick) {
             this.bounds = bounds;
             if (!isTick) {

src/plugins/LADTable/components/LADTable.vue

@@ -36,7 +36,6 @@
                 v-for="item in items"
                 :key="item.key"
                 :domain-object="item.domainObject"
-                :object-path="objectPath"
                 :has-units="hasUnits"
             />
         </tbody>
@@ -48,20 +47,10 @@
 import LadRow from './LADRow.vue';
 
 export default {
-    inject: ['openmct'],
+    inject: ['openmct', 'domainObject', 'objectPath'],
     components: {
         LadRow
     },
-    props: {
-        domainObject: {
-            type: Object,
-            required: true
-        },
-        objectPath: {
-            type: Array,
-            required: true
-        }
-    },
     data() {
         return {
             items: []

src/plugins/condition/Condition.js

@@ -75,8 +75,7 @@ export default class Condition extends EventEmitter {
             return;
         }
 
-        // if all the criteria in this condition have no telemetry, we want to force the condition result to evaluate
-        if (this.hasNoTelemetry() || this.isTelemetryUsed(datum.id)) {
+        if (this.isTelemetryUsed(datum.id)) {
 
             this.criteria.forEach(criterion => {
                 if (this.isAnyOrAllTelemetry(criterion)) {
@@ -94,12 +93,6 @@ export default class Condition extends EventEmitter {
         return (criterion.telemetry && (criterion.telemetry === 'all' || criterion.telemetry === 'any'));
     }
 
-    hasNoTelemetry() {
-        return this.criteria.every((criterion) => {
-            return !this.isAnyOrAllTelemetry(criterion) && criterion.telemetry === '';
-        });
-    }
-
     isTelemetryUsed(id) {
         return this.criteria.some(criterion => {
             return this.isAnyOrAllTelemetry(criterion) || criterion.telemetryObjectIdAsString === id;
@@ -257,17 +250,10 @@ export default class Condition extends EventEmitter {
     }
 
     getTriggerDescription() {
-        if (this.trigger) {
-            return {
-                conjunction: TRIGGER_CONJUNCTION[this.trigger],
-                prefix: `${TRIGGER_LABEL[this.trigger]}: `
-            };
-        } else {
-            return {
-                conjunction: '',
-                prefix: ''
-            };
-        }
+        return {
+            conjunction: TRIGGER_CONJUNCTION[this.trigger],
+            prefix: `${TRIGGER_LABEL[this.trigger]}: `
+        };
     }
 
     requestLADConditionResult() {

src/plugins/condition/ConditionManager.js

@@ -79,17 +79,6 @@ export default class ConditionManager extends EventEmitter {
         delete this.subscriptions[id];
         delete this.telemetryObjects[id];
         this.removeConditionTelemetryObjects();
-
-        //force re-computation of condition set result as we might be in a state where
-        // there is no telemetry datum coming in for a while or at all.
-        let latestTimestamp = getLatestTimestamp(
-            {},
-            {},
-            this.timeSystems,
-            this.openmct.time.timeSystem()
-        );
-        this.updateConditionResults({id: id});
-        this.updateCurrentCondition(latestTimestamp);
     }
 
     initialize() {
@@ -347,17 +336,14 @@ export default class ConditionManager extends EventEmitter {
         let timestamp = {};
         timestamp[timeSystemKey] = normalizedDatum[timeSystemKey];
 
-        this.updateConditionResults(normalizedDatum);
-        this.updateCurrentCondition(timestamp);
-    }
-
-    updateConditionResults(normalizedDatum) {
         //We want to stop when the first condition evaluates to true.
         this.conditions.some((condition) => {
             condition.updateResult(normalizedDatum);
 
             return condition.result === true;
         });
+
+        this.updateCurrentCondition(timestamp);
     }
 
     updateCurrentCondition(timestamp) {

src/plugins/condition/StyleRuleManager.js

@@ -86,7 +86,6 @@ export default class StyleRuleManager extends EventEmitter {
     updateObjectStyleConfig(styleConfiguration) {
         if (!styleConfiguration || !styleConfiguration.conditionSetIdentifier) {
             this.initialize(styleConfiguration || {});
-            this.applyStaticStyle();
             this.destroy();
         } else {
             let isNewConditionSet = !this.conditionSetIdentifier
@@ -159,6 +158,7 @@ export default class StyleRuleManager extends EventEmitter {
     }
 
     destroy() {
+        this.applyStaticStyle();
         if (this.stopProvidingTelemetry) {
             this.stopProvidingTelemetry();
             delete this.stopProvidingTelemetry;

src/plugins/condition/components/inspector/ConditionSetDialogTreeItem.vue

@@ -31,6 +31,7 @@
             v-model="expanded"
             class="c-tree__item__view-control"
             :enabled="hasChildren"
+            :propagate="false"
         />
         <div class="c-tree__item__label c-object-label">
             <div

src/plugins/condition/pluginSpec.js

@@ -22,7 +22,6 @@
 
 import { createOpenMct, resetApplicationState } from "utils/testing";
 import ConditionPlugin from "./plugin";
-import stylesManager from '@/ui/inspector/styles/StylesManager';
 import StylesView from "./components/inspector/StylesView.vue";
 import Vue from 'vue';
 import {getApplicableStylesForItem} from "./utils/styleUtils";
@@ -403,8 +402,7 @@ describe('the plugin', function () {
             component = new Vue({
                 provide: {
                     openmct: openmct,
-                    selection: selection,
-                    stylesManager
+                    selection: selection
                 },
                 el: viewContainer,
                 components: {

src/plugins/displayLayout/components/DisplayLayout.vue

@@ -152,7 +152,10 @@ export default {
         }
     },
     data() {
+        let domainObject = JSON.parse(JSON.stringify(this.domainObject));
+
         return {
+            internalDomainObject: domainObject,
             initSelectIndex: undefined,
             selection: [],
             showGrid: true
@@ -160,10 +163,10 @@ export default {
     },
     computed: {
         gridSize() {
-            return this.domainObject.configuration.layoutGrid;
+            return this.internalDomainObject.configuration.layoutGrid;
         },
         layoutItems() {
-            return this.domainObject.configuration.items;
+            return this.internalDomainObject.configuration.items;
         },
         selectedLayoutItems() {
             return this.layoutItems.filter(item => {
@@ -171,7 +174,7 @@ export default {
             });
         },
         layoutDimensions() {
-            return this.domainObject.configuration.layoutDimensions;
+            return this.internalDomainObject.configuration.layoutDimensions;
         },
         shouldDisplayLayoutDimensions() {
             return this.layoutDimensions
@@ -203,9 +206,12 @@ export default {
         }
     },
     mounted() {
+        this.unlisten = this.openmct.objects.observe(this.internalDomainObject, '*', function (obj) {
+            this.internalDomainObject = JSON.parse(JSON.stringify(obj));
+        }.bind(this));
         this.openmct.selection.on('change', this.setSelection);
         this.initializeItems();
-        this.composition = this.openmct.composition.get(this.domainObject);
+        this.composition = this.openmct.composition.get(this.internalDomainObject);
         this.composition.on('add', this.addChild);
         this.composition.on('remove', this.removeChild);
         this.composition.load();
@@ -214,6 +220,7 @@ export default {
         this.openmct.selection.off('change', this.setSelection);
         this.composition.off('add', this.addChild);
         this.composition.off('remove', this.removeChild);
+        this.unlisten();
     },
     methods: {
         addElement(itemType, element) {
@@ -340,7 +347,7 @@ export default {
             this.startingMinY2 = undefined;
         },
         mutate(path, value) {
-            this.openmct.objects.mutate(this.domainObject, path, value);
+            this.openmct.objects.mutate(this.internalDomainObject, path, value);
         },
         handleDrop($event) {
             if (!$event.dataTransfer.types.includes('openmct/domain-object-path')) {
@@ -380,11 +387,11 @@ export default {
             }
         },
         containsObject(identifier) {
-            return _.get(this.domainObject, 'composition')
+            return _.get(this.internalDomainObject, 'composition')
                 .some(childId => this.openmct.objects.areIdsEqual(childId, identifier));
         },
         handleDragOver($event) {
-            if (this.domainObject.locked) {
+            if (this.internalDomainObject.locked) {
                 return;
             }
 
@@ -413,7 +420,7 @@ export default {
             item.id = uuid();
             this.trackItem(item);
             this.layoutItems.push(item);
-            this.openmct.objects.mutate(this.domainObject, "configuration.items", this.layoutItems);
+            this.openmct.objects.mutate(this.internalDomainObject, "configuration.items", this.layoutItems);
             this.initSelectIndex = this.layoutItems.length - 1;
         },
         trackItem(item) {
@@ -470,7 +477,7 @@ export default {
             }
         },
         removeFromComposition(keyString) {
-            let composition = _.get(this.domainObject, 'composition');
+            let composition = _.get(this.internalDomainObject, 'composition');
             composition = composition.filter(identifier => {
                 return this.openmct.objects.makeKeyString(identifier) !== keyString;
             });
@@ -622,10 +629,10 @@ export default {
         createNewDomainObject(domainObject, composition, viewType, nameExtension, model) {
             let identifier = {
                 key: uuid(),
-                namespace: this.domainObject.identifier.namespace
+                namespace: this.internalDomainObject.identifier.namespace
             };
             let type = this.openmct.types.get(viewType);
-            let parentKeyString = this.openmct.objects.makeKeyString(this.domainObject.identifier);
+            let parentKeyString = this.openmct.objects.makeKeyString(this.internalDomainObject.identifier);
             let objectName = nameExtension ? `${domainObject.name}-${nameExtension}` : domainObject.name;
             let object = {};
 
@@ -682,7 +689,7 @@ export default {
             });
         },
         duplicateItem(selectedItems) {
-            let objectStyles = this.domainObject.configuration.objectStyles || {};
+            let objectStyles = this.internalDomainObject.configuration.objectStyles || {};
             let selectItemsArray = [];
             let newDomainObjectsArray = [];
 
@@ -721,8 +728,8 @@ export default {
             });
 
             this.$nextTick(() => {
-                this.openmct.objects.mutate(this.domainObject, "configuration.items", this.layoutItems);
-                this.openmct.objects.mutate(this.domainObject, "configuration.objectStyles", objectStyles);
+                this.openmct.objects.mutate(this.internalDomainObject, "configuration.items", this.layoutItems);
+                this.openmct.objects.mutate(this.internalDomainObject, "configuration.objectStyles", objectStyles);
                 this.$el.click(); //clear selection;
 
                 newDomainObjectsArray.forEach(domainObject => {
@@ -761,13 +768,13 @@ export default {
             };
             this.createNewDomainObject(mockDomainObject, overlayPlotIdentifiers, viewType).then((newDomainObject) => {
                 let newDomainObjectKeyString = this.openmct.objects.makeKeyString(newDomainObject.identifier);
-                let domainObjectKeyString = this.openmct.objects.makeKeyString(this.domainObject.identifier);
+                let internalDomainObjectKeyString = this.openmct.objects.makeKeyString(this.internalDomainObject.identifier);
 
                 this.composition.add(newDomainObject);
                 this.addItem('subobject-view', newDomainObject, position);
 
                 overlayPlots.forEach(overlayPlot => {
-                    if (overlayPlot.location === domainObjectKeyString) {
+                    if (overlayPlot.location === internalDomainObjectKeyString) {
                         this.openmct.objects.mutate(overlayPlot, 'location', newDomainObjectKeyString);
                     }
                 });

src/plugins/displayLayout/components/SubobjectView.vue

@@ -129,22 +129,13 @@ export default {
         }
     },
     mounted() {
-        if (this.openmct.objects.supportsMutation(this.item.identifier)) {
-            this.openmct.objects.getMutable(this.item.identifier)
-                .then(this.setObject);
-        } else {
-            this.openmct.objects.get(this.item.identifier)
-                .then(this.setObject);
-        }
+        this.openmct.objects.get(this.item.identifier)
+            .then(this.setObject);
     },
-    beforeDestroy() {
+    destroyed() {
         if (this.removeSelectable) {
             this.removeSelectable();
         }
-
-        if (this.domainObject.isMutable) {
-            this.openmct.objects.destroyMutable(this.domainObject);
-        }
     },
     methods: {
         setObject(domainObject) {

src/plugins/displayLayout/components/TelemetryView.vue

@@ -212,20 +212,14 @@ export default {
         }
     },
     mounted() {
-        if (this.openmct.objects.supportsMutation(this.item.identifier)) {
-            this.openmct.objects.getMutable(this.item.identifier)
-                .then(this.setObject);
-        } else {
-            this.openmct.objects.get(this.item.identifier)
-                .then(this.setObject);
-        }
-
+        this.openmct.objects.get(this.item.identifier)
+            .then(this.setObject);
         this.openmct.time.on("bounds", this.refreshData);
 
         this.status = this.openmct.status.get(this.item.identifier);
         this.removeStatusListener = this.openmct.status.observe(this.item.identifier, this.setStatus);
     },
-    beforeDestroy() {
+    destroyed() {
         this.removeSubscription();
         this.removeStatusListener();
 
@@ -234,18 +228,13 @@ export default {
         }
 
         this.openmct.time.off("bounds", this.refreshData);
-
-        if (this.domainObject.isMutable) {
-            this.openmct.objects.destroyMutable(this.domainObject);
-        }
     },
     methods: {
         formattedValueForCopy() {
             const timeFormatterKey = this.openmct.time.timeSystem().key;
             const timeFormatter = this.formats[timeFormatterKey];
-            const unit = this.unit ? ` ${this.unit}` : '';
 
-            return `At ${timeFormatter.format(this.datum)} ${this.domainObject.name} had a value of ${this.telemetryValue}${unit}`;
+            return `At ${timeFormatter.format(this.datum)} ${this.domainObject.name} had a value of ${this.telemetryValue} ${this.unit}`;
         },
         requestHistoricalData() {
             let bounds = this.openmct.time.bounds();

src/plugins/duplicate/DuplicateAction.js

@@ -89,7 +89,7 @@ export default class DuplicateAction {
                         {
                             key: "name",
                             control: "textfield",
-                            name: "Name",
+                            name: "Folder Name",
                             pattern: "\\S+",
                             required: true,
                             cssClass: "l-input-lg"

src/plugins/duplicate/DuplicateTask.js

@@ -48,14 +48,13 @@ export default class DuplicateTask {
     }
 
     /**
-     * Execute the duplicate/copy task with the objects provided.
+     * Execute the duplicate/copy task with the objects provided in the constructor.
      * @returns {promise} Which will resolve with a clone of the object
      * once complete.
      */
     async duplicate(domainObject, parent, filter) {
         this.domainObject = domainObject;
         this.parent = parent;
-        this.namespace = parent.identifier.namespace;
         this.filter = filter || this.isCreatable;
 
         await this.buildDuplicationPlan();
@@ -79,9 +78,8 @@ export default class DuplicateTask {
      */
     async buildDuplicationPlan() {
         let domainObjectClone = await this.duplicateObject(this.domainObject);
-
         if (domainObjectClone !== this.domainObject) {
-            domainObjectClone.location = this.getKeyString(this.parent);
+            domainObjectClone.location = this.getId(this.parent);
         }
 
         this.firstClone = domainObjectClone;
@@ -98,14 +96,13 @@ export default class DuplicateTask {
         let initialCount = this.clones.length;
         let dialog = this.openmct.overlays.progressDialog({
             progressPerc: 0,
-            message: `Duplicating ${initialCount} objects.`,
+            message: `Duplicating ${initialCount} files.`,
             iconClass: 'info',
             title: 'Duplicating'
         });
-
-        let clonesDone = Promise.all(this.clones.map((clone) => {
+        let clonesDone = Promise.all(this.clones.map(clone => {
             let percentPersisted = Math.ceil(100 * (++this.persisted / initialCount));
-            let message = `Duplicating ${initialCount - this.persisted} objects.`;
+            let message = `Duplicating ${initialCount - this.persisted} files.`;
 
             dialog.updateProgress(percentPersisted, message);
 
@@ -113,7 +110,6 @@ export default class DuplicateTask {
         }));
 
         await clonesDone;
-
         dialog.dismiss();
         this.openmct.notifications.info(`Duplicated ${this.persisted} objects.`);
 
@@ -145,7 +141,10 @@ export default class DuplicateTask {
     async duplicateObject(originalObject) {
         // Check if the creatable (or other passed in filter).
         if (this.filter(originalObject)) {
+            // Clone original object
             let clone = this.cloneObjectModel(originalObject);
+
+            // Get children, if any
             let composeesCollection = this.openmct.composition.get(originalObject);
             let composees;
 
@@ -153,6 +152,7 @@ export default class DuplicateTask {
                 composees = await composeesCollection.load();
             }
 
+            // Recursively duplicate children
             return this.duplicateComposees(clone, composees);
         }
 
@@ -160,6 +160,36 @@ export default class DuplicateTask {
         return originalObject;
     }
 
+    /**
+     * Update identifiers in a cloned object model (or part of
+     * a cloned object model) to reflect new identifiers after
+     * duplicating.
+     * @private
+     */
+    rewriteIdentifiers(obj, idMap) {
+        function lookupValue(value) {
+            return (typeof value === 'string' && idMap[value]) || value;
+        }
+
+        if (Array.isArray(obj)) {
+            obj.forEach((value, index) => {
+                obj[index] = lookupValue(value);
+                this.rewriteIdentifiers(obj[index], idMap);
+            });
+        } else if (obj && typeof obj === 'object') {
+            Object.keys(obj).forEach((key) => {
+                let value = obj[key];
+                obj[key] = lookupValue(value);
+                if (idMap[key]) {
+                    delete obj[key];
+                    obj[idMap[key]] = value;
+                }
+
+                this.rewriteIdentifiers(value, idMap);
+            });
+        }
+    }
+
     /**
      * Given an array of objects composed by a parent, clone them, then
      * add them to the parent.
@@ -167,67 +197,34 @@ export default class DuplicateTask {
      * @returns {*}
      */
     async duplicateComposees(clonedParent, composees = []) {
-        let idMappings = [];
+        let idMap = {};
+
         let allComposeesDuplicated = composees.reduce(async (previousPromise, nextComposee) => {
             await previousPromise;
-
             let clonedComposee = await this.duplicateObject(nextComposee);
-
-            if (clonedComposee) {
-                idMappings.push({
-                    newId: clonedComposee.identifier,
-                    oldId: nextComposee.identifier
-                });
-                this.composeChild(clonedComposee, clonedParent, clonedComposee !== nextComposee);
-            }
+            idMap[this.getId(nextComposee)] = this.getId(clonedComposee);
+            await this.composeChild(clonedComposee, clonedParent, clonedComposee !== nextComposee);
 
             return;
         }, Promise.resolve());
 
         await allComposeesDuplicated;
 
-        clonedParent = this.rewriteIdentifiers(clonedParent, idMappings);
+        this.rewriteIdentifiers(clonedParent, idMap);
         this.clones.push(clonedParent);
 
         return clonedParent;
     }
 
-    /**
-     * Update identifiers in a cloned object model (or part of
-     * a cloned object model) to reflect new identifiers after
-     * duplicating.
-     * @private
-     */
-    rewriteIdentifiers(clonedParent, childIdMappings) {
-        for (let { newId, oldId } of childIdMappings) {
-            let newIdKeyString = this.openmct.objects.makeKeyString(newId);
-            let oldIdKeyString = this.openmct.objects.makeKeyString(oldId);
-
-            // regex replace keystrings
-            clonedParent = JSON.stringify(clonedParent).replace(new RegExp(oldIdKeyString, 'g'), newIdKeyString);
-
-            // parse reviver to replace identifiers
-            clonedParent = JSON.parse(clonedParent, (key, value) => {
-                if (Object.prototype.hasOwnProperty.call(value, 'key')
-                    && Object.prototype.hasOwnProperty.call(value, 'namespace')
-                    && value.key === oldId.key
-                    && value.namespace === oldId.namespace) {
-                    return newId;
-                } else {
-                    return value;
-                }
-            });
-        }
-
-        return clonedParent;
-    }
-
-    composeChild(child, parent, setLocation) {
-        parent.composition.push(child.identifier);
+    async composeChild(child, parent, setLocation) {
+        const PERSIST_BOOL = false;
+        let parentComposition = this.openmct.composition.get(parent);
+        await parentComposition.load();
+        parentComposition.add(child, PERSIST_BOOL);
 
         //If a location is not specified, set it.
         if (setLocation && child.location === undefined) {
-            let parentKeyString = this.getKeyString(parent);
+            let parentKeyString = this.getId(parent);
             child.location = parentKeyString;
         }
     }
@@ -242,7 +239,7 @@ export default class DuplicateTask {
         let clone = JSON.parse(JSON.stringify(domainObject));
         let identifier = {
             key: uuid(),
-            namespace: this.namespace // set to NEW parent's namespace
+            namespace: domainObject.identifier.namespace
         };
 
         if (clone.modified || clone.persisted || clone.location) {
@@ -263,7 +260,7 @@ export default class DuplicateTask {
         return clone;
     }
 
-    getKeyString(domainObject) {
+    getId(domainObject) {
         return this.openmct.objects.makeKeyString(domainObject.identifier);
     }
 

src/plugins/duplicate/pluginSpec.js

@@ -57,7 +57,6 @@ describe("The Duplicate Action plugin", () => {
             overwrite: {
                 folder: {
                     name: "Parent Folder",
-                    type: "folder",
                     composition: [childObject.identifier]
                 }
             }
@@ -105,7 +104,6 @@ describe("The Duplicate Action plugin", () => {
 
         // already installed by default, but never hurts, just adds to context menu
         openmct.install(DuplicateActionPlugin());
-        openmct.types.addType('folder', {creatable: true});
 
         openmct.on('start', done);
         openmct.startHeadless();

src/plugins/folderView/components/ListItem.vue

@@ -1,9 +1,7 @@
 <template>
 <tr
     class="c-list-item"
-    :class="{
-        'is-alias': item.isAlias === true
-    }"
+    :class="{ 'is-alias': item.isAlias === true }"
     @click="navigate"
 >
     <td class="c-list-item__name">

src/plugins/imagery/components/ImageryViewLayout.vue

@@ -36,7 +36,7 @@
         <div class="c-imagery__main-image__bg"
              :class="{'paused unnsynced': isPaused,'stale':false }"
         >
-            <div class="c-imagery__main-image__image js-imageryView-image"
+            <div class="c-imagery__main-image__image"
                  :style="{
                      'background-image': imageUrl ? `url(${imageUrl})` : 'none',
                      'filter': `brightness(${filters.brightness}%) contrast(${filters.contrast}%)`

src/plugins/imagery/pluginSpec.js

@@ -1,306 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-import ImageryPlugin from './plugin.js';
-import Vue from 'vue';
-import {
-    createOpenMct,
-    resetApplicationState,
-    simulateKeyEvent
-} from 'utils/testing';
-
-const ONE_MINUTE = 1000 * 60;
-const TEN_MINUTES = ONE_MINUTE * 10;
-const MAIN_IMAGE_CLASS = '.js-imageryView-image';
-const NEW_IMAGE_CLASS = '.c-imagery__age.c-imagery--new';
-const REFRESH_CSS_MS = 500;
-
-function getImageInfo(doc) {
-    let imageElement = doc.querySelectorAll(MAIN_IMAGE_CLASS)[0];
-    let timestamp = imageElement.dataset.openmctImageTimestamp;
-    let identifier = imageElement.dataset.openmctObjectKeystring;
-    let url = imageElement.style.backgroundImage;
-
-    return {
-        timestamp,
-        identifier,
-        url
-    };
-}
-
-function isNew(doc) {
-    let newIcon = doc.querySelectorAll(NEW_IMAGE_CLASS);
-
-    return newIcon.length !== 0;
-}
-
-function generateTelemetry(start, count) {
-    let telemetry = [];
-
-    for (let i = 1, l = count + 1; i < l; i++) {
-        let stringRep = i + 'minute';
-        let logo = 'images/logo-openmct.svg';
-
-        telemetry.push({
-            "name": stringRep + " Imagery",
-            "utc": start + (i * ONE_MINUTE),
-            "url": location.host + '/' + logo + '?time=' + stringRep,
-            "timeId": stringRep
-        });
-    }
-
-    return telemetry;
-}
-
-describe("The Imagery View Layout", () => {
-    const imageryKey = 'example.imagery';
-    const START = Date.now();
-    const COUNT = 10;
-
-    let openmct;
-    let imageryPlugin;
-    let parent;
-    let child;
-    let timeFormat = 'utc';
-    let bounds = {
-        start: START - TEN_MINUTES,
-        end: START
-    };
-    let imageTelemetry = generateTelemetry(START - TEN_MINUTES, COUNT);
-    let imageryObject = {
-        identifier: {
-            namespace: "",
-            key: "imageryId"
-        },
-        name: "Example Imagery",
-        type: "example.imagery",
-        location: "parentId",
-        modified: 0,
-        persisted: 0,
-        telemetry: {
-            values: [
-                {
-                    "name": "Image",
-                    "key": "url",
-                    "format": "image",
-                    "hints": {
-                        "image": 1,
-                        "priority": 3
-                    },
-                    "source": "url"
-                },
-                {
-                    "name": "Name",
-                    "key": "name",
-                    "source": "name",
-                    "hints": {
-                        "priority": 0
-                    }
-                },
-                {
-                    "name": "Time",
-                    "key": "utc",
-                    "format": "utc",
-                    "hints": {
-                        "domain": 2,
-                        "priority": 1
-                    },
-                    "source": "utc"
-                },
-                {
-                    "name": "Local Time",
-                    "key": "local",
-                    "format": "local-format",
-                    "hints": {
-                        "domain": 1,
-                        "priority": 2
-                    },
-                    "source": "local"
-                }
-            ]
-        }
-    };
-
-    // this setups up the app
-    beforeEach((done) => {
-        const appHolder = document.createElement('div');
-        appHolder.style.width = '640px';
-        appHolder.style.height = '480px';
-
-        openmct = createOpenMct();
-
-        parent = document.createElement('div');
-        child = document.createElement('div');
-        parent.appendChild(child);
-
-        spyOn(openmct.telemetry, 'request').and.returnValue(Promise.resolve([]));
-
-        imageryPlugin = new ImageryPlugin();
-        openmct.install(imageryPlugin);
-
-        spyOn(openmct.objects, 'get').and.returnValue(Promise.resolve({}));
-
-        openmct.time.timeSystem(timeFormat, {
-            start: 0,
-            end: 4
-        });
-
-        openmct.on('start', done);
-        openmct.startHeadless(appHolder);
-    });
-
-    afterEach(() => {
-        return resetApplicationState(openmct);
-    });
-
-    it("should provide an imagery view only for imagery producing objects", () => {
-        let applicableViews = openmct.objectViews.get(imageryObject);
-        let imageryView = applicableViews.find(
-            viewProvider => viewProvider.key === imageryKey
-        );
-
-        expect(imageryView).toBeDefined();
-    });
-
-    describe("imagery view", () => {
-        let applicableViews;
-        let imageryViewProvider;
-        let imageryView;
-
-        beforeEach(async (done) => {
-            let telemetryRequestResolve;
-            let telemetryRequestPromise = new Promise((resolve) => {
-                telemetryRequestResolve = resolve;
-            });
-
-            openmct.telemetry.request.and.callFake(() => {
-                telemetryRequestResolve(imageTelemetry);
-
-                return telemetryRequestPromise;
-            });
-
-            openmct.time.clock('local', {
-                start: bounds.start,
-                end: bounds.end + 100
-            });
-
-            applicableViews = openmct.objectViews.get(imageryObject);
-            imageryViewProvider = applicableViews.find(viewProvider => viewProvider.key === imageryKey);
-            imageryView = imageryViewProvider.view(imageryObject);
-            imageryView.show(child);
-
-            await telemetryRequestPromise;
-            await Vue.nextTick();
-
-            return done();
-        });
-
-        it("on mount should show the the most recent image", () => {
-            const imageInfo = getImageInfo(parent);
-
-            expect(imageInfo.url.indexOf(imageTelemetry[COUNT - 1].timeId)).not.toEqual(-1);
-        });
-
-        it("should show the clicked thumbnail as the main image", async () => {
-            const target = imageTelemetry[5].url;
-            parent.querySelectorAll(`img[src='${target}']`)[0].click();
-            await Vue.nextTick();
-            const imageInfo = getImageInfo(parent);
-
-            expect(imageInfo.url.indexOf(imageTelemetry[5].timeId)).not.toEqual(-1);
-        });
-
-        it("should show that an image is new", async (done) => {
-            await Vue.nextTick();
-
-            // used in code, need to wait to the 500ms here too
-            setTimeout(() => {
-                const imageIsNew = isNew(parent);
-
-                expect(imageIsNew).toBeTrue();
-                done();
-            }, REFRESH_CSS_MS);
-        });
-
-        it("should show that an image is not new", async (done) => {
-            const target = imageTelemetry[2].url;
-            parent.querySelectorAll(`img[src='${target}']`)[0].click();
-
-            await Vue.nextTick();
-
-            // used in code, need to wait to the 500ms here too
-            setTimeout(() => {
-                const imageIsNew = isNew(parent);
-
-                expect(imageIsNew).toBeFalse();
-                done();
-            }, REFRESH_CSS_MS);
-        });
-
-        it("should navigate via arrow keys", async () => {
-            let keyOpts = {
-                element: parent.querySelector('.c-imagery'),
-                key: 'ArrowLeft',
-                keyCode: 37,
-                type: 'keyup'
-            };
-
-            simulateKeyEvent(keyOpts);
-
-            await Vue.nextTick();
-
-            const imageInfo = getImageInfo(parent);
-
-            expect(imageInfo.url.indexOf(imageTelemetry[COUNT - 2].timeId)).not.toEqual(-1);
-        });
-
-        it("should navigate via numerous arrow keys", async () => {
-            let element = parent.querySelector('.c-imagery');
-            let type = 'keyup';
-            let leftKeyOpts = {
-                element,
-                type,
-                key: 'ArrowLeft',
-                keyCode: 37
-            };
-            let rightKeyOpts = {
-                element,
-                type,
-                key: 'ArrowRight',
-                keyCode: 39
-            };
-
-            // left thrice
-            simulateKeyEvent(leftKeyOpts);
-            simulateKeyEvent(leftKeyOpts);
-            simulateKeyEvent(leftKeyOpts);
-            // right once
-            simulateKeyEvent(rightKeyOpts);
-
-            await Vue.nextTick();
-
-            const imageInfo = getImageInfo(parent);
-
-            expect(imageInfo.url.indexOf(imageTelemetry[COUNT - 3].timeId)).not.toEqual(-1);
-        });
-
-    });
-});

src/plugins/localTimeSystem/pluginSpec.js

@@ -1,114 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-
-import {
-    createOpenMct,
-    resetApplicationState
-} from 'utils/testing';
-
-describe("The local time", () => {
-    const LOCAL_FORMAT_KEY = 'local-format';
-    const LOCAL_SYSTEM_KEY = 'local';
-    const JUNK = "junk";
-    const TIMESTAMP = -14256000000;
-    const DATESTRING = '1969-07-20 12:00:00.000 am';
-    let openmct;
-
-    beforeEach((done) => {
-
-        openmct = createOpenMct();
-
-        openmct.install(openmct.plugins.LocalTimeSystem());
-
-        openmct.on('start', done);
-        openmct.startHeadless();
-
-    });
-
-    afterEach(() => {
-        return resetApplicationState(openmct);
-    });
-
-    describe("system", function () {
-
-        let localTimeSystem;
-
-        beforeEach(() => {
-            localTimeSystem = openmct.time.timeSystem(LOCAL_SYSTEM_KEY, {
-                start: 0,
-                end: 4
-            });
-        });
-
-        it("is installed", () => {
-            let timeSystems = openmct.time.getAllTimeSystems();
-            let local = timeSystems.find(ts => ts.key === LOCAL_SYSTEM_KEY);
-
-            expect(local).not.toEqual(-1);
-        });
-
-        it("can be set to be the main time system", () => {
-            expect(openmct.time.timeSystem().key).toBe(LOCAL_SYSTEM_KEY);
-        });
-
-        it("uses the local-format time format", () => {
-            expect(localTimeSystem.timeFormat).toBe(LOCAL_FORMAT_KEY);
-        });
-
-        it("is UTC based", () => {
-            expect(localTimeSystem.isUTCBased).toBe(true);
-        });
-
-        it("defines expected metadata", () => {
-            expect(localTimeSystem.key).toBe(LOCAL_SYSTEM_KEY);
-            expect(localTimeSystem.name).toBeDefined();
-            expect(localTimeSystem.cssClass).toBeDefined();
-            expect(localTimeSystem.durationFormat).toBeDefined();
-        });
-    });
-
-    describe("formatter can be obtained from the telemetry API and", () => {
-
-        let localTimeFormatter;
-        let dateString;
-        let timeStamp;
-
-        beforeEach(() => {
-            localTimeFormatter = openmct.telemetry.getFormatter(LOCAL_FORMAT_KEY);
-            dateString = localTimeFormatter.format(TIMESTAMP);
-            timeStamp = localTimeFormatter.parse(DATESTRING);
-        });
-
-        it("will format a timestamp in local time format", () => {
-            expect(localTimeFormatter.format(TIMESTAMP)).toBe(dateString);
-        });
-
-        it("will parse an local time Date String into milliseconds", () => {
-            expect(localTimeFormatter.parse(DATESTRING)).toBe(timeStamp);
-        });
-
-        it("will validate correctly", () => {
-            expect(localTimeFormatter.validate(DATESTRING)).toBe(true);
-            expect(localTimeFormatter.validate(JUNK)).toBe(false);
-        });
-    });
-});

src/plugins/notebook/components/Notebook.vue

@@ -225,12 +225,14 @@ export default {
         },
         createNotebookStorageObject() {
             const notebookMeta = {
+                name: this.internalDomainObject.name,
                 identifier: this.internalDomainObject.identifier
             };
             const page = this.getSelectedPage();
             const section = this.getSelectedSection();
 
             return {
+                domainObject: this.internalDomainObject,
                 notebookMeta,
                 section,
                 page
@@ -440,10 +442,10 @@ export default {
         async updateDefaultNotebook(notebookStorage) {
             const defaultNotebookObject = await this.getDefaultNotebookObject();
             if (!defaultNotebookObject) {
-                setDefaultNotebook(this.openmct, notebookStorage, this.internalDomainObject);
+                setDefaultNotebook(this.openmct, notebookStorage);
             } else if (objectUtils.makeKeyString(defaultNotebookObject.identifier) !== objectUtils.makeKeyString(notebookStorage.notebookMeta.identifier)) {
                 this.removeDefaultClass(defaultNotebookObject);
-                setDefaultNotebook(this.openmct, notebookStorage, this.internalDomainObject);
+                setDefaultNotebook(this.openmct, notebookStorage);
             }
 
             if (this.defaultSectionId && this.defaultSectionId.length === 0 || this.defaultSectionId !== notebookStorage.section.id) {

src/plugins/notebook/components/NotebookEmbed.vue

@@ -143,9 +143,9 @@ export default {
                 this.openmct.notifications.alert(message);
             }
 
-            const relativeHash = hash.slice(hash.indexOf('#'));
-            const url = new URL(relativeHash, `${location.protocol}//${location.host}${location.pathname}`);
-            window.location.hash = url.hash;
+            const link = `${location.host}${location.pathname}${hash}`;
+            const url = new URL(link);
+            window.location.href = url.hash;
         },
         formatTime(unixTime, timeFormat) {
             return Moment.utc(unixTime).format(timeFormat);

src/plugins/notebook/components/NotebookMenuSwitcher.vue

@@ -44,46 +44,38 @@ export default {
     },
     data() {
         return {
-            notebookSnapshot: undefined,
+            notebookSnapshot: null,
             notebookTypes: []
         };
     },
     mounted() {
         validateNotebookStorageObject();
-        this.getDefaultNotebookObject();
 
         this.notebookSnapshot = new Snapshot(this.openmct);
         this.setDefaultNotebookStatus();
     },
     methods: {
-        async getDefaultNotebookObject() {
-            const defaultNotebook = getDefaultNotebook();
-            const defaultNotebookObject = defaultNotebook && await this.openmct.objects.get(defaultNotebook.notebookMeta.identifier);
-
-            return defaultNotebookObject;
-        },
-        async showMenu(event) {
+        showMenu(event) {
             const notebookTypes = [];
+            const defaultNotebook = getDefaultNotebook();
             const elementBoundingClientRect = this.$el.getBoundingClientRect();
             const x = elementBoundingClientRect.x;
             const y = elementBoundingClientRect.y + elementBoundingClientRect.height;
 
-            const defaultNotebookObject = await this.getDefaultNotebookObject();
-            if (defaultNotebookObject) {
-                const name = defaultNotebookObject.name;
+            if (defaultNotebook) {
+                const domainObject = defaultNotebook.domainObject;
 
-                const defaultNotebook = getDefaultNotebook();
-                const sectionName = defaultNotebook.section.name;
-                const pageName = defaultNotebook.page.name;
-                const defaultPath = `${name} - ${sectionName} - ${pageName}`;
+                if (domainObject.location) {
+                    const defaultPath = `${domainObject.name} - ${defaultNotebook.section.name} - ${defaultNotebook.page.name}`;
 
-                notebookTypes.push({
-                    cssClass: 'icon-notebook',
-                    name: `Save to Notebook ${defaultPath}`,
-                    callBack: () => {
-                        return this.snapshot(NOTEBOOK_DEFAULT);
-                    }
-                });
+                    notebookTypes.push({
+                        cssClass: 'icon-notebook',
+                        name: `Save to Notebook ${defaultPath}`,
+                        callBack: () => {
+                            return this.snapshot(NOTEBOOK_DEFAULT);
+                        }
+                    });
+                }
             }
 
             notebookTypes.push({

src/plugins/notebook/pluginSpec.js

@@ -20,7 +20,7 @@
  * at runtime from the About dialog for additional information.
  *****************************************************************************/
 
-import { createOpenMct, createMouseEvent, resetApplicationState } from 'utils/testing';
+import { createOpenMct, resetApplicationState } from 'utils/testing';
 import NotebookPlugin from './plugin';
 import Vue from 'vue';
 
@@ -133,89 +133,4 @@ describe("Notebook plugin:", () => {
             expect(hasMajorElements).toBe(true);
         });
     });
-
-    describe("Notebook Snapshots view:", () => {
-        let snapshotIndicator;
-        let drawerElement;
-
-        function clickSnapshotIndicator() {
-            const indicator = element.querySelector('.icon-camera');
-            const button = indicator.querySelector('button');
-            const clickEvent = createMouseEvent('click');
-
-            button.dispatchEvent(clickEvent);
-        }
-
-        beforeAll(() => {
-            snapshotIndicator = openmct.indicators.indicatorObjects
-                .find(indicator => indicator.key === 'notebook-snapshot-indicator').element;
-
-            element.append(snapshotIndicator);
-
-            return Vue.nextTick();
-        });
-
-        afterAll(() => {
-            snapshotIndicator.remove();
-            snapshotIndicator = undefined;
-
-            if (drawerElement) {
-                drawerElement.remove();
-                drawerElement = undefined;
-            }
-        });
-
-        beforeEach(() => {
-            drawerElement = document.querySelector('.l-shell__drawer');
-        });
-
-        afterEach(() => {
-            if (drawerElement) {
-                drawerElement.classList.remove('is-expanded');
-            }
-        });
-
-        it("has Snapshots indicator", () => {
-            const hasSnapshotIndicator = snapshotIndicator !== null && snapshotIndicator !== undefined;
-            expect(hasSnapshotIndicator).toBe(true);
-        });
-
-        it("snapshots container has class isExpanded", () => {
-            let classes = drawerElement.classList;
-            const isExpandedBefore = classes.contains('is-expanded');
-
-            clickSnapshotIndicator();
-            classes = drawerElement.classList;
-            const isExpandedAfterFirstClick = classes.contains('is-expanded');
-
-            expect(isExpandedBefore).toBeFalse();
-            expect(isExpandedAfterFirstClick).toBeTrue();
-        });
-
-        it("snapshots container does not have class isExpanded", () => {
-            let classes = drawerElement.classList;
-            const isExpandedBefore = classes.contains('is-expanded');
-
-            clickSnapshotIndicator();
-            classes = drawerElement.classList;
-            const isExpandedAfterFirstClick = classes.contains('is-expanded');
-
-            clickSnapshotIndicator();
-            classes = drawerElement.classList;
-            const isExpandedAfterSecondClick = classes.contains('is-expanded');
-
-            expect(isExpandedBefore).toBeFalse();
-            expect(isExpandedAfterFirstClick).toBeTrue();
-            expect(isExpandedAfterSecondClick).toBeFalse();
-        });
-
-        it("show notebook snapshots container text", () => {
-            clickSnapshotIndicator();
-
-            const notebookSnapshots = drawerElement.querySelector('.l-browse-bar__object-name');
-            const snapshotsText = notebookSnapshots.textContent.trim();
-
-            expect(snapshotsText).toBe('Notebook Snapshots');
-        });
-    });
 });

src/plugins/notebook/snapshot.js

@@ -7,14 +7,15 @@ export default class Snapshot {
     constructor(openmct) {
         this.openmct = openmct;
         this.snapshotContainer = new SnapshotContainer(openmct);
+        this.exportImageService = openmct.$injector.get('exportImageService');
+        this.dialogService = openmct.$injector.get('dialogService');
 
         this.capture = this.capture.bind(this);
         this._saveSnapShot = this._saveSnapShot.bind(this);
     }
 
     capture(snapshotMeta, notebookType, domElement) {
-        const exportImageService = this.openmct.$injector.get('exportImageService');
-        exportImageService.exportPNGtoSRC(domElement, 's-status-taking-snapshot')
+        this.exportImageService.exportPNGtoSRC(domElement, 's-status-taking-snapshot')
             .then(function (blob) {
                 const reader = new window.FileReader();
                 reader.readAsDataURL(blob);

src/plugins/notebook/utils/notebook-entriesSpec.js

@@ -23,6 +23,13 @@ import * as NotebookEntries from './notebook-entries';
 import { createOpenMct, resetApplicationState } from 'utils/testing';
 
 const notebookStorage = {
+    domainObject: {
+        name: 'notebook',
+        identifier: {
+            namespace: '',
+            key: 'test-notebook'
+        }
+    },
     notebookMeta: {
         name: 'notebook',
         identifier: {
@@ -113,13 +120,6 @@ let openmct;
 describe('Notebook Entries:', () => {
     beforeEach(done => {
         openmct = createOpenMct();
-        openmct.types.addType('notebook', {
-            creatable: true
-        });
-        openmct.objects.addProvider('', jasmine.createSpyObj('mockNotebookProvider', [
-            'create',
-            'update'
-        ]));
         window.localStorage.setItem('notebook-storage', null);
 
         done();

src/plugins/notebook/utils/notebook-storage.js

@@ -1,12 +1,13 @@
-import objectUtils from 'objectUtils';
-
 const NOTEBOOK_LOCAL_STORAGE = 'notebook-storage';
-let currentNotebookObjectIdentifier = null;
+let currentNotebookObject = null;
 let unlisten = null;
 
 function defaultNotebookObjectChanged(newDomainObject) {
     if (newDomainObject.location !== null) {
-        currentNotebookObjectIdentifier = newDomainObject.identifier;
+        currentNotebookObject = newDomainObject;
+        const notebookStorage = getDefaultNotebook();
+        notebookStorage.domainObject = newDomainObject;
+        saveDefaultNotebook(notebookStorage);
 
         return;
     }
@@ -19,9 +20,10 @@ function defaultNotebookObjectChanged(newDomainObject) {
     clearDefaultNotebook();
 }
 
-function observeDefaultNotebookObject(openmct, notebookMeta, domainObject) {
-    if (currentNotebookObjectIdentifier
-            && objectUtils.makeKeyString(currentNotebookObjectIdentifier) === objectUtils.makeKeyString(notebookMeta.identifier)) {
+function observeDefaultNotebookObject(openmct, notebookStorage) {
+    const domainObject = notebookStorage.domainObject;
+    if (currentNotebookObject
+            && currentNotebookObject.identifier.key === domainObject.identifier.key) {
         return;
     }
 
@@ -30,7 +32,7 @@ function observeDefaultNotebookObject(openmct, notebookMeta, domainObject) {
         unlisten = null;
     }
 
-    unlisten = openmct.objects.observe(domainObject, '*', defaultNotebookObjectChanged);
+    unlisten = openmct.objects.observe(notebookStorage.domainObject, '*', defaultNotebookObjectChanged);
 }
 
 function saveDefaultNotebook(notebookStorage) {
@@ -38,7 +40,7 @@ function saveDefaultNotebook(notebookStorage) {
 }
 
 export function clearDefaultNotebook() {
-    currentNotebookObjectIdentifier = null;
+    currentNotebookObject = null;
     window.localStorage.setItem(NOTEBOOK_LOCAL_STORAGE, null);
 }
 
@@ -48,8 +50,8 @@ export function getDefaultNotebook() {
     return JSON.parse(notebookStorage);
 }
 
-export function setDefaultNotebook(openmct, notebookStorage, domainObject) {
-    observeDefaultNotebookObject(openmct, notebookStorage.notebookMeta, domainObject);
+export function setDefaultNotebook(openmct, notebookStorage) {
+    observeDefaultNotebookObject(openmct, notebookStorage);
     saveDefaultNotebook(notebookStorage);
 }
 

src/plugins/notebook/utils/notebook-storageSpec.js

@@ -23,15 +23,14 @@
 import * as NotebookStorage from './notebook-storage';
 import { createOpenMct, resetApplicationState } from 'utils/testing';
 
-const domainObject = {
-    name: 'notebook',
-    identifier: {
-        namespace: '',
-        key: 'test-notebook'
-    }
-};
-
 const notebookStorage = {
+    domainObject: {
+        name: 'notebook',
+        identifier: {
+            namespace: '',
+            key: 'test-notebook'
+        }
+    },
     notebookMeta: {
         name: 'notebook',
         identifier: {
@@ -62,10 +61,7 @@ describe('Notebook Storage:', () => {
     beforeEach((done) => {
         openmct = createOpenMct();
         window.localStorage.setItem('notebook-storage', null);
-        openmct.objects.addProvider('', jasmine.createSpyObj('mockNotebookProvider', [
-            'create',
-            'update'
-        ]));
+
         done();
     });
 
@@ -86,7 +82,7 @@ describe('Notebook Storage:', () => {
     });
 
     it('has correct notebookstorage on setDefaultNotebook', () => {
-        NotebookStorage.setDefaultNotebook(openmct, notebookStorage, domainObject);
+        NotebookStorage.setDefaultNotebook(openmct, notebookStorage);
         const defaultNotebook = NotebookStorage.getDefaultNotebook();
 
         expect(JSON.stringify(defaultNotebook)).toBe(JSON.stringify(notebookStorage));
@@ -102,7 +98,7 @@ describe('Notebook Storage:', () => {
             sectionTitle: 'Section'
         };
 
-        NotebookStorage.setDefaultNotebook(openmct, notebookStorage, domainObject);
+        NotebookStorage.setDefaultNotebook(openmct, notebookStorage);
         NotebookStorage.setDefaultNotebookSection(section);
 
         const defaultNotebook = NotebookStorage.getDefaultNotebook();
@@ -119,7 +115,7 @@ describe('Notebook Storage:', () => {
             pageTitle: 'Page'
         };
 
-        NotebookStorage.setDefaultNotebook(openmct, notebookStorage, domainObject);
+        NotebookStorage.setDefaultNotebook(openmct, notebookStorage);
         NotebookStorage.setDefaultNotebookPage(page);
 
         const defaultNotebook = NotebookStorage.getDefaultNotebook();

src/plugins/performanceIndicator/README.md

@@ -1,9 +0,0 @@
-# URL Indicator
-Adds an indicator which shows the number of frames that the browser is able to render per second. This is a useful proxy for the maximum number of updates that any telemetry display can perform per second. This may be useful during performance testing, but probably should not be enabled by default. 
-
-This indicator adds adds about 3% points to CPU usage in the Chrome task manager.
-
-## Installation
-```js
-openmct.install(openmct.plugins.PerformanceIndicator());
-```

src/plugins/performanceIndicator/plugin.js

@@ -1,62 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-export default function PerformanceIndicator() {
-    return function install(openmct) {
-        let frames = 0;
-        let lastCalculated = performance.now();
-        const indicator = openmct.indicators.simpleIndicator();
-
-        indicator.text('~ fps');
-        indicator.statusClass('s-status-info');
-        openmct.indicators.add(indicator);
-
-        let rafHandle = requestAnimationFrame(incremementFrames);
-
-        openmct.on('destroy', () => {
-            cancelAnimationFrame(rafHandle);
-        });
-
-        function incremementFrames() {
-            let now = performance.now();
-            if ((now - lastCalculated) < 1000) {
-                frames++;
-            } else {
-                updateFPS(frames);
-                lastCalculated = now;
-                frames = 1;
-            }
-
-            rafHandle = requestAnimationFrame(incremementFrames);
-        }
-
-        function updateFPS(fps) {
-            indicator.text(`${fps} fps`);
-            if (fps >= 40) {
-                indicator.statusClass('s-status-on');
-            } else if (fps < 40 && fps >= 20) {
-                indicator.statusClass('s-status-warning');
-            } else {
-                indicator.statusClass('s-status-error');
-            }
-        }
-    };
-}

src/plugins/performanceIndicator/pluginSpec.js

@@ -1,87 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-import PerformancePlugin from './plugin.js';
-import {
-    createOpenMct,
-    resetApplicationState
-} from 'utils/testing';
-
-describe('the plugin', () => {
-    let openmct;
-    let element;
-    let child;
-
-    let performanceIndicator;
-    let countFramesPromise;
-
-    beforeEach((done) => {
-        openmct = createOpenMct(false);
-
-        element = document.createElement('div');
-        child = document.createElement('div');
-        element.appendChild(child);
-
-        openmct.install(new PerformancePlugin());
-
-        countFramesPromise = countFrames();
-
-        openmct.on('start', done);
-
-        performanceIndicator = openmct.indicators.indicatorObjects.find((indicator) => {
-            return indicator.text && indicator.text() === '~ fps';
-        });
-
-        openmct.startHeadless();
-    });
-
-    afterEach(() => {
-        return resetApplicationState(openmct);
-    });
-
-    it('installs the performance indicator', () => {
-        expect(performanceIndicator).toBeDefined();
-    });
-
-    it('correctly calculates fps', () => {
-        return countFramesPromise.then((frames) => {
-            expect(performanceIndicator.text()).toEqual(`${frames} fps`);
-        });
-    });
-
-    function countFrames() {
-        let startTime = performance.now();
-        let frames = 0;
-
-        return new Promise((resolve) => {
-            requestAnimationFrame(function incrementCount() {
-                let now = performance.now();
-
-                if ((now - startTime) < 1000) {
-                    frames++;
-                    requestAnimationFrame(incrementCount);
-                } else {
-                    resolve(frames);
-                }
-            });
-        });
-    }
-});

src/plugins/persistence/couch/pluginSpec.js

@@ -39,12 +39,10 @@ describe('the plugin', () => {
             identifier: {
                 namespace: 'mct',
                 key: 'some-value'
-            },
-            type: 'mock-type'
+            }
         };
         openmct = createOpenMct(false);
         openmct.install(new CouchPlugin(testPath));
-        openmct.types.addType('mock-type', {creatable: true});
 
         element = document.createElement('div');
         child = document.createElement('div');

src/plugins/plot/src/services/ExportImageService.js

@@ -117,10 +117,8 @@ define(
          * @returns {promise}
          */
         ExportImageService.prototype.exportJPG = function (element, filename, className) {
-            const processedFilename = replaceDotsWithUnderscores(filename);
-
             return this.renderElement(element, "jpg", className).then(function (img) {
-                saveAs(img, processedFilename);
+                saveAs(img, filename);
             });
         };
 
@@ -132,10 +130,8 @@ define(
          * @returns {promise}
          */
         ExportImageService.prototype.exportPNG = function (element, filename, className) {
-            const processedFilename = replaceDotsWithUnderscores(filename);
-
             return this.renderElement(element, "png", className).then(function (img) {
-                saveAs(img, processedFilename);
+                saveAs(img, filename);
             });
         };
 
@@ -150,12 +146,6 @@ define(
             return this.renderElement(element, "png", className);
         };
 
-        function replaceDotsWithUnderscores(filename) {
-            const regex = /\./gi;
-
-            return filename.replace(regex, '_');
-        }
-
         /**
          * canvas.toBlob() not supported in IE < 10, Opera, and Safari. This polyfill
          * implements the method in browsers that would not otherwise support it.

src/plugins/plot/src/telemetry/StackedPlotController.js

@@ -39,11 +39,10 @@ define([], function () {
             const thisRequest = {
                 pending: 0
             };
-            const telemetryObjects = $scope.telemetryObjects = [];
-            const thisTickWidthMap = {};
-
             currentRequest = thisRequest;
             $scope.currentRequest = thisRequest;
+            const telemetryObjects = $scope.telemetryObjects = [];
+            const thisTickWidthMap = {};
             tickWidthMap = thisTickWidthMap;
 
             if (unlisten) {
@@ -53,10 +52,14 @@ define([], function () {
 
             function addChild(child) {
                 const id = openmct.objects.makeKeyString(child.identifier);
-                const legacyObject = openmct.legacyObject(child);
-
                 thisTickWidthMap[id] = 0;
-                telemetryObjects.push(legacyObject);
+                thisRequest.pending += 1;
+                objectService.getObjects([id])
+                    .then(function (objects) {
+                        thisRequest.pending -= 1;
+                        const childObj = objects[id];
+                        telemetryObjects.push(childObj);
+                    });
             }
 
             function removeChild(childIdentifier) {
@@ -81,7 +84,6 @@ define([], function () {
             }
 
             thisRequest.pending += 1;
-
             openmct.objects.get(domainObject.getId())
                 .then(function (obj) {
                     thisRequest.pending -= 1;

src/plugins/plugins.js

@@ -60,8 +60,7 @@ define([
     './defaultRootName/plugin',
     './timeline/plugin',
     './viewDatumAction/plugin',
-    './interceptors/plugin',
-    './performanceIndicator/plugin'
+    './interceptors/plugin'
 ], function (
     _,
     UTCTimeSystem,
@@ -102,8 +101,7 @@ define([
     DefaultRootName,
     Timeline,
     ViewDatumAction,
-    ObjectInterceptors,
-    PerformanceIndicator
+    ObjectInterceptors
 ) {
     const bundleMap = {
         LocalStorage: 'platform/persistence/local',
@@ -199,7 +197,6 @@ define([
     plugins.Timeline = Timeline.default;
     plugins.ViewDatumAction = ViewDatumAction.default;
     plugins.ObjectInterceptors = ObjectInterceptors.default;
-    plugins.PerformanceIndicator = PerformanceIndicator.default;
 
     return plugins;
 });

src/plugins/tabs/components/tabs.vue

@@ -55,7 +55,7 @@
         <object-view
             v-if="internalDomainObject.keep_alive ? currentTab : isCurrent(tab)"
             class="c-tabs-view__object"
-            :default-object="tab.domainObject"
+            :object="tab.domainObject"
             :object-path="tab.objectPath"
         />
     </div>

src/plugins/tabs/pluginSpec.js

@@ -0,0 +1,110 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2020, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+
+import {
+    createOpenMct,
+    resetApplicationState
+} from 'utils/testing';
+
+fdescribe("the tabs plugin", () => {
+    let openmct;
+
+    beforeEach((done) => {
+        openmct = createOpenMct();
+        openmct.on('start', done);
+        openmct.startHeadless();
+    });
+
+    afterEach(() => {
+        return resetApplicationState(openmct);
+    });
+
+    it("defines a tabs object that is creatable", () => {
+        const tabsType = openmct.types.get('tabs');
+
+        expect(tabsType.definition.creatable).toBe(true);
+    });
+
+    it("defines a form to configure the tabs object", () => {
+        const tabsType = openmct.types.get('tabs');
+
+        expect(tabsType.definition.form).toBeDefined();
+    });
+
+    it("provides a tabs view", () => {
+        const domainObject = {
+            identifier: {
+                namespace: '',
+                key: 'mock-tabs-object'
+            },
+            type: 'tabs'
+        };
+        const applicableViews = openmct.objectViews.get(domainObject);
+        const tabsView = applicableViews.find((viewProvider) => viewProvider.key === 'tabs');
+
+        expect(tabsView).toBeDefined();
+    });
+
+    describe("the tabs view", () => {
+        it("displays instructional text instead of tabs if no tabs exist", () => {
+            const domainObject = {
+                identifier: {
+                    namespace: '',
+                    key: 'mock-tabs-object'
+                },
+                type: 'tabs'
+            };
+            const element = document.createElement('div');
+            const child = document.createElement('div');
+            element.appendChild(child);
+
+            const applicableViews = openmct.objectViews.get(domainObject);
+            const tabsViewProvider = applicableViews.find((viewProvider) => viewProvider.key === 'tabs');
+            const tabsView = tabsViewProvider.view(domainObject, [domainObject]);
+            tabsView.show(child, true);
+
+            const noTabsElement = getNoTabsElement(element);
+
+            expect(noTabsElement).not.toBeNull();
+        });
+
+        it("creates a tab for each object dropped into the drop zone", () => {
+
+        });
+
+        it("creates a tab level for objects dropped into current tab view", () => {
+
+        });
+
+        it("removes a tab and tab contents", () => {
+
+        });
+    });
+
+    function getNoTabsElement(parent) {
+        return parent.querySelector('.c-tabs-view__empty-message');
+    }
+
+    function getTabElements(parent) {
+        return parent.querySelectorAll('.c-tabs-view__tab');
+    }
+});

src/plugins/telemetryTable/TelemetryTableRow.js

@@ -100,13 +100,11 @@ define([], function () {
      * @param {*} metadataValues
      */
     function createNormalizedDatum(datum, columns) {
-        const normalizedDatum = JSON.parse(JSON.stringify(datum));
-
-        Object.values(columns).forEach(column => {
+        return Object.values(columns).reduce((normalizedDatum, column) => {
             normalizedDatum[column.getKey()] = column.getRawValue(datum);
-        });
 
-        return normalizedDatum;
+            return normalizedDatum;
+        }, {});
     }
 
     return TelemetryTableRow;

src/plugins/telemetryTable/ViewActions.js

@@ -30,13 +30,13 @@ let exportCSV = {
     },
     group: 'view'
 };
-let exportMarkedDataAsCSV = {
+let exportMarkedRows = {
     name: 'Export Marked Rows',
     key: 'export-csv-marked',
     description: "Export marked rows as CSV",
     cssClass: 'icon-download labeled',
     invoke: (objectPath, viewProvider) => {
-        viewProvider.getViewContext().exportMarkedDataAsCSV();
+        viewProvider.getViewContext().exportMarkedRows();
     },
     group: 'view'
 };
@@ -98,7 +98,7 @@ let autosizeColumns = {
 
 let viewActions = [
     exportCSV,
-    exportMarkedDataAsCSV,
+    exportMarkedRows,
     unmarkAllRows,
     pause,
     play,

src/plugins/telemetryTable/components/table.vue

@@ -960,7 +960,7 @@ export default {
             return {
                 type: 'telemetry-table',
                 exportAllDataAsCSV: this.exportAllDataAsCSV,
-                exportMarkedDataAsCSV: this.exportMarkedDataAsCSV,
+                exportMarkedRows: this.exportMarkedRows,
                 unmarkAllRows: this.unmarkAllRows,
                 togglePauseByButton: this.togglePauseByButton,
                 expandColumns: this.recalculateColumnWidths,

src/plugins/telemetryTable/pluginSpec.js

@@ -68,10 +68,6 @@ describe("the plugin", () => {
             end: 4
         });
 
-        openmct.types.addType('test-object', {
-            creatable: true
-        });
-
         spyOnBuiltins(['requestAnimationFrame']);
         window.requestAnimationFrame.and.callFake((callBack) => {
             callBack();

src/plugins/timeConductor/Conductor.vue

@@ -157,7 +157,6 @@
 </template>
 
 <script>
-import _ from 'lodash';
 import ConductorMode from './ConductorMode.vue';
 import ConductorTimeSystem from './ConductorTimeSystem.vue';
 import DatePicker from './DatePicker.vue';
@@ -221,7 +220,7 @@ export default {
         document.addEventListener('keydown', this.handleKeyDown);
         document.addEventListener('keyup', this.handleKeyUp);
         this.setTimeSystem(JSON.parse(JSON.stringify(this.openmct.time.timeSystem())));
-        this.openmct.time.on('bounds', _.throttle(this.handleNewBounds, 300));
+        this.openmct.time.on('bounds', this.handleNewBounds);
         this.openmct.time.on('timeSystem', this.setTimeSystem);
         this.openmct.time.on('clock', this.setViewFromClock);
         this.openmct.time.on('clockOffsets', this.setViewFromOffsets);

src/plugins/timeConductor/conductor-mode-icon.scss

@@ -56,7 +56,7 @@
         $handW: 2px;
         $handH: $d * 0.4;
         animation-iteration-count: infinite;
-        animation-timing-function: steps(12);
+        animation-timing-function: linear;
         transform-origin: bottom;
         position: absolute;
         height: $handW;

src/plugins/timeline/pluginSpec.js

@@ -98,10 +98,6 @@ describe('the plugin', function () {
 
         beforeEach((done) => {
             planDomainObject = {
-                identifier: {
-                    key: 'test-object',
-                    namespace: ''
-                },
                 type: 'plan',
                 id: "test-object",
                 selectFile: {

src/selection/Selection.js

@@ -70,8 +70,11 @@ define(
             if (multiSelect) {
                 this.handleMultiSelect(selectable);
             } else {
-                this.handleSingleSelect(selectable);
+                this.setSelectionStyles(selectable);
+                this.selected = [selectable];
             }
+
+            this.emit('change', this.selected);
         };
 
         /**
@@ -84,20 +87,6 @@ define(
                 this.addSelectionAttributes(selectable);
                 this.selected.push(selectable);
             }
-
-            this.emit('change', this.selected);
-        };
-
-        /**
-         * @private
-         */
-        Selection.prototype.handleSingleSelect = function (selectable) {
-            if (!_.isEqual([selectable], this.selected)) {
-                this.setSelectionStyles(selectable);
-                this.selected = [selectable];
-
-                this.emit('change', this.selected);
-            }
         };
 
         /**
@@ -241,8 +230,11 @@ define(
             element.addEventListener('click', capture, true);
             element.addEventListener('click', selectCapture);
 
+            let unlisten = undefined;
             if (context.item) {
-                context.item = this.openmct.objects._toMutable(context.item);
+                unlisten = this.openmct.objects.observe(context.item, "*", function (newItem) {
+                    context.item = newItem;
+                });
             }
 
             if (select) {
@@ -253,14 +245,14 @@ define(
                 }
             }
 
-            return (function () {
+            return function () {
                 element.removeEventListener('click', capture, true);
                 element.removeEventListener('click', selectCapture);
 
-                if (context.item !== undefined && context.item.isMutable) {
-                    this.openmct.objects.destroyMutable(context.item);
+                if (unlisten !== undefined) {
+                    unlisten();
                 }
-            }).bind(this);
+            };
         };
 
         return Selection;

src/styles/_controls.scss

@@ -482,7 +482,7 @@ select {
         transition: $transIn;
         white-space: nowrap;
 
-        @include hover {
+        &:hover {
             background: $colorMenuHovBg;
             color: $colorMenuHovFg;
             &:before {
@@ -500,10 +500,6 @@ select {
         &:not([class*='icon']):before {
              content: ''; // Enable :before so that menu items without an icon still indent properly
         }
-
-        .menus-no-icon & {
-            &:before { display: none; }
-        }
     }
 }
 
@@ -735,6 +731,7 @@ select {
 .c-toolbar {
     display: flex;
     align-items: center;
+    justify-content: space-between;
 
     > * {
         // First level items

src/styles/_legacy-plots.scss

@@ -47,7 +47,6 @@ mct-plot {
 .c-plot,
 .gl-plot {
     overflow: hidden;
-    min-height: 100px;
 
         .s-status-taking-snapshot & {
         .c-control-bar {
@@ -80,8 +79,7 @@ mct-plot {
         display: flex;
         flex: 1 1 auto;
         flex-direction: column;
-        overflow-y: auto;
-        overflow-x: hidden;
+        overflow: hidden;
     }
 
     &--stacked {

src/styles/_mixins.scss

@@ -552,8 +552,7 @@
         }
     }
 
-    &[class*='--menus-left'],
-    &[class*='menus-to-left'] {
+    &[class*='--menus-left'] {
         .c-menu {
             left: auto; right: 0;
         }

src/ui/components/ObjectFrame.vue

@@ -88,6 +88,7 @@
     <object-view
         ref="objectView"
         class="c-so-view__object-view"
+        :object="domainObject"
         :show-edit-view="showEditView"
         :object-path="objectPath"
         :layout-font-size="layoutFontSize"
@@ -160,7 +161,6 @@ export default {
     mounted() {
         this.status = this.openmct.status.get(this.domainObject.identifier);
         this.removeStatusListener = this.openmct.status.observe(this.domainObject.identifier, this.setStatus);
-        this.$refs.objectView.show(this.domainObject, undefined, false, this.objectPath);
     },
     beforeDestroy() {
         this.removeStatusListener();

src/ui/components/ObjectLabel.vue

@@ -3,6 +3,7 @@
     class="c-tree__item__label c-object-label"
     :class="[statusClass]"
     draggable="true"
+    :href="objectLink"
     @dragstart="dragStart"
     @click="navigateOrPreview"
 >
@@ -15,7 +16,7 @@
         ></span>
     </div>
     <div class="c-tree__item__name c-object-label__name">
-        {{ domainObject.name }}
+        {{ observedObject.name }}
     </div>
 </a>
 </template>
@@ -45,12 +46,13 @@ export default {
     },
     data() {
         return {
+            observedObject: this.domainObject,
             status: ''
         };
     },
     computed: {
         typeClass() {
-            let type = this.openmct.types.get(this.domainObject.type);
+            let type = this.openmct.types.get(this.observedObject.type);
             if (!type) {
                 return 'icon-object-unknown';
             }
@@ -62,8 +64,15 @@ export default {
         }
     },
     mounted() {
-        this.removeStatusListener = this.openmct.status.observe(this.domainObject.identifier, this.setStatus);
-        this.status = this.openmct.status.get(this.domainObject.identifier);
+        if (this.observedObject) {
+            let removeListener = this.openmct.objects.observe(this.observedObject, '*', (newObject) => {
+                this.observedObject = newObject;
+            });
+            this.$once('hook:destroyed', removeListener);
+        }
+
+        this.removeStatusListener = this.openmct.status.observe(this.observedObject.identifier, this.setStatus);
+        this.status = this.openmct.status.get(this.observedObject.identifier);
         this.previewAction = new PreviewAction(this.openmct);
     },
     destroyed() {
@@ -75,8 +84,6 @@ export default {
                 event.preventDefault();
                 this.preview();
             }
-
-            window.location.assign(this.objectLink);
         },
         preview() {
             if (this.previewAction.appliesTo(this.objectPath)) {
@@ -93,7 +100,7 @@ export default {
              * that point. If dragged object can be composed by navigated object, then indicate with presence of
              * 'composable-domain-object' in data transfer
              */
-            if (this.openmct.composition.checkPolicy(navigatedObject, this.domainObject)) {
+            if (this.openmct.composition.checkPolicy(navigatedObject, this.observedObject)) {
                 event.dataTransfer.setData("openmct/composable-domain-object", JSON.stringify(this.domainObject));
             }
 

src/ui/components/ObjectView.vue

@@ -10,11 +10,11 @@ import {STYLE_CONSTANTS} from "@/plugins/condition/utils/constants";
 export default {
     inject: ["openmct"],
     props: {
-        showEditView: Boolean,
-        defaultObject: {
+        object: {
             type: Object,
             default: undefined
         },
+        showEditView: Boolean,
         objectPath: {
             type: Array,
             default: () => {
@@ -32,12 +32,12 @@ export default {
     },
     data() {
         return {
-            domainObject: this.defaultObject
+            currentObject: this.object
         };
     },
     computed: {
         objectFontStyle() {
-            return this.domainObject && this.domainObject.configuration && this.domainObject.configuration.fontStyle;
+            return this.currentObject && this.currentObject.configuration && this.currentObject.configuration.fontStyle;
         },
         fontSize() {
             return this.objectFontStyle ? this.objectFontStyle.fontSize : this.layoutFontSize;
@@ -46,12 +46,22 @@ export default {
             return this.objectFontStyle ? this.objectFontStyle.font : this.layoutFont;
         }
     },
+    watch: {
+        object(newObject, oldObject) {
+            this.currentObject = newObject;
+            this.debounceUpdateView();
+        }
+    },
     destroyed() {
         this.clear();
         if (this.releaseEditModeHandler) {
             this.releaseEditModeHandler();
         }
 
+        if (this.unlisten) {
+            this.unlisten();
+        }
+
         if (this.stopListeningStyles) {
             this.stopListeningStyles();
         }
@@ -82,7 +92,7 @@ export default {
             capture: true
         });
         this.$el.addEventListener('drop', this.addObjectToParent);
-        if (this.domainObject) {
+        if (this.currentObject) {
             //This is to apply styles to subobjects in a layout
             this.initObjectStyles();
         }
@@ -125,7 +135,7 @@ export default {
         invokeEditModeHandler(editMode) {
             let edit;
 
-            if (this.domainObject.locked) {
+            if (this.currentObject.locked) {
                 edit = false;
             } else {
                 edit = editMode;
@@ -165,13 +175,13 @@ export default {
         },
         updateView(immediatelySelect) {
             this.clear();
-            if (!this.domainObject) {
+            if (!this.currentObject) {
                 return;
             }
 
-            this.composition = this.openmct.composition.get(this.domainObject);
-
+            this.composition = this.openmct.composition.get(this.currentObject);
             if (this.composition) {
+                this.composition._synchronize();
                 this.loadComposition();
             }
 
@@ -187,15 +197,15 @@ export default {
 
             if (provider.edit && this.showEditView) {
                 if (this.openmct.editor.isEditing()) {
-                    this.currentView = provider.edit(this.domainObject, true, objectPath);
+                    this.currentView = provider.edit(this.currentObject, true, objectPath);
                 } else {
-                    this.currentView = provider.view(this.domainObject, objectPath);
+                    this.currentView = provider.view(this.currentObject, objectPath);
                 }
 
                 this.openmct.editor.on('isEditing', this.toggleEditView);
                 this.releaseEditModeHandler = () => this.openmct.editor.off('isEditing', this.toggleEditView);
             } else {
-                this.currentView = provider.view(this.domainObject, objectPath);
+                this.currentView = provider.view(this.currentObject, objectPath);
 
                 if (this.currentView.onEditModeChange) {
                     this.openmct.editor.on('isEditing', this.invokeEditModeHandler);
@@ -237,12 +247,16 @@ export default {
                 this.composition._destroy();
             }
 
-            this.domainObject = object;
+            this.currentObject = object;
 
             if (currentObjectPath) {
                 this.currentObjectPath = currentObjectPath;
             }
 
+            this.unlisten = this.openmct.objects.observe(this.currentObject, '*', (mutatedObject) => {
+                this.currentObject = mutatedObject;
+            });
+
             this.viewKey = viewKey;
 
             this.updateView(immediatelySelect);
@@ -251,16 +265,16 @@ export default {
         },
         initObjectStyles() {
             if (!this.styleRuleManager) {
-                this.styleRuleManager = new StyleRuleManager((this.domainObject.configuration && this.domainObject.configuration.objectStyles), this.openmct, this.updateStyle.bind(this), true);
+                this.styleRuleManager = new StyleRuleManager((this.currentObject.configuration && this.currentObject.configuration.objectStyles), this.openmct, this.updateStyle.bind(this), true);
             } else {
-                this.styleRuleManager.updateObjectStyleConfig(this.domainObject.configuration && this.domainObject.configuration.objectStyles);
+                this.styleRuleManager.updateObjectStyleConfig(this.currentObject.configuration && this.currentObject.configuration.objectStyles);
             }
 
             if (this.stopListeningStyles) {
                 this.stopListeningStyles();
             }
 
-            this.stopListeningStyles = this.openmct.objects.observe(this.domainObject, 'configuration.objectStyles', (newObjectStyle) => {
+            this.stopListeningStyles = this.openmct.objects.observe(this.currentObject, 'configuration.objectStyles', (newObjectStyle) => {
                 //Updating styles in the inspector view will trigger this so that the changes are reflected immediately
                 this.styleRuleManager.updateObjectStyleConfig(newObjectStyle);
             });
@@ -268,7 +282,7 @@ export default {
             this.setFontSize(this.fontSize);
             this.setFont(this.font);
 
-            this.stopListeningFontStyles = this.openmct.objects.observe(this.domainObject, 'configuration.fontStyle', (newFontStyle) => {
+            this.stopListeningFontStyles = this.openmct.objects.observe(this.currentObject, 'configuration.fontStyle', (newFontStyle) => {
                 this.setFontSize(newFontStyle.fontSize);
                 this.setFont(newFontStyle.font);
             });
@@ -280,7 +294,7 @@ export default {
             if (this.currentView && this.currentView.getSelectionContext) {
                 return this.currentView.getSelectionContext();
             } else {
-                return { item: this.domainObject };
+                return { item: this.currentObject };
             }
         },
         onDragOver(event) {
@@ -307,7 +321,7 @@ export default {
             let provider = this.openmct.objectViews.getByProviderKey(this.viewKey);
 
             if (!provider) {
-                provider = this.openmct.objectViews.get(this.domainObject)[0];
+                provider = this.openmct.objectViews.get(this.currentObject)[0];
                 if (!provider) {
                     return;
                 }
@@ -319,7 +333,7 @@ export default {
             let provider = this.getViewProvider();
             if (provider
                 && provider.canEdit
-                && provider.canEdit(this.domainObject)
+                && provider.canEdit(this.currentObject)
                 && this.isEditingAllowed()
                 && !this.openmct.editor.isEditing()) {
                 this.openmct.editor.edit();
@@ -336,7 +350,7 @@ export default {
         clearData(domainObject) {
             if (domainObject) {
                 let clearKeyString = this.openmct.objects.makeKeyString(domainObject.identifier);
-                let currentObjectKeyString = this.openmct.objects.makeKeyString(this.domainObject.identifier);
+                let currentObjectKeyString = this.openmct.objects.makeKeyString(this.currentObject.identifier);
 
                 if (clearKeyString === currentObjectKeyString) {
                     if (this.currentView.onClearData) {
@@ -350,11 +364,11 @@ export default {
             }
         },
         isEditingAllowed() {
-            let browseObject = this.openmct.layout.$refs.browseObject.domainObject;
+            let browseObject = this.openmct.layout.$refs.browseObject.currentObject;
             let objectPath = this.currentObjectPath || this.objectPath;
             let parentObject = objectPath[1];
 
-            return [browseObject, parentObject, this.domainObject].every(object => object && !object.locked);
+            return [browseObject, parentObject, this.currentObject].every(object => object && !object.locked);
         },
         setFontSize(newSize) {
             let elemToStyle = this.getStyleReceiver();

src/ui/components/object-frame.scss

@@ -162,5 +162,5 @@
     // This element is the recipient for object styling; cannot be display: contents
     flex: 1 1 auto;
     overflow: hidden;
-    display: block;
+    display: contents;
 }

src/ui/components/viewControl.vue

@@ -22,6 +22,10 @@ export default {
             type: Boolean,
             default: false
         },
+        propagate: {
+            type: Boolean,
+            default: true
+        },
         controlClass: {
             type: String,
             default: 'c-disclosure-triangle'
@@ -29,8 +33,10 @@ export default {
     },
     methods: {
         handleClick(event) {
-            event.stopPropagation();
             this.$emit('input', !this.value);
+            if (!this.propagate) {
+                event.stopPropagation();
+            }
         }
     }
 };

src/ui/inspector/Elements.vue

@@ -82,6 +82,10 @@ export default {
         this.openmct.editor.off('isEditing', this.setEditState);
         this.openmct.selection.off('change', this.showSelection);
 
+        if (this.mutationUnobserver) {
+            this.mutationUnobserver();
+        }
+
         if (this.compositionUnlistener) {
             this.compositionUnlistener();
         }
@@ -102,11 +106,18 @@ export default {
             this.listeners = [];
             this.parentObject = selection && selection[0] && selection[0][0].context.item;
 
+            if (this.mutationUnobserver) {
+                this.mutationUnobserver();
+            }
+
             if (this.compositionUnlistener) {
                 this.compositionUnlistener();
             }
 
             if (this.parentObject) {
+                this.mutationUnobserver = this.openmct.objects.observe(this.parentObject, '*', (updatedModel) => {
+                    this.parentObject = updatedModel;
+                });
                 this.composition = this.openmct.composition.get(this.parentObject);
 
                 if (this.composition) {

src/ui/inspector/styles/FontStyleEditor.vue

@@ -1,13 +1,11 @@
 <template>
 <div class="c-toolbar">
     <toolbar-select-menu
-        class="menus-to-left menus-no-icon"
         :options="fontSizeMenuOptions"
         @change="setFontSize"
     />
     <div class="c-toolbar__separator"></div>
     <toolbar-select-menu
-        class="menus-to-left menus-no-icon"
         :options="fontMenuOptions"
         @change="setFont"
     />

src/ui/layout/BrowseBar.vue

@@ -20,7 +20,7 @@
             </div>
             <span
                 class="l-browse-bar__object-name c-object-label__name c-input-inline"
-                :contenteditable="type.creatable"
+                contenteditable
                 @blur="updateName"
                 @keydown.enter.prevent
                 @keyup.enter.prevent="updateNameOnEnterKeyPress"
@@ -211,6 +211,14 @@ export default {
     },
     watch: {
         domainObject() {
+            if (this.mutationObserver) {
+                this.mutationObserver();
+            }
+
+            this.mutationObserver = this.openmct.objects.observe(this.domainObject, '*', (domainObject) => {
+                this.domainObject = domainObject;
+            });
+
             if (this.removeStatusListener) {
                 this.removeStatusListener();
             }

src/ui/layout/layout.scss

@@ -279,12 +279,10 @@
     }
 
     &__toolbar {
-        // Toolbar in the main shell, used by Display Layouts
         $p: $interiorMargin;
         background: $editUIBaseColor;
         border-radius: $basicCr;
         height: $p + 24px; // Need to standardize the height
-        justify-content: space-between;
         padding: $p;
     }
 }

src/ui/layout/mct-tree.scss

@@ -95,10 +95,6 @@
                 color: $colorItemTreeSelectedFg;
             }
         }
-
-        &.is-context-clicked {
-            box-shadow: inset $colorItemTreeSelectedBg 0 0 0 1px;
-        }
     }
 }
 

src/ui/layout/mct-tree.vue

@@ -65,7 +65,7 @@
                 v-for="(ancestor, index) in focusedAncestors"
                 :key="ancestor.id"
                 :node="ancestor"
-                :show-up="index < focusedAncestors.length - 1 && initialLoad"
+                :show-up="index < focusedAncestors.length - 1"
                 :show-down="false"
                 :left-offset="index * 10 + 'px'"
                 @resetTree="beginNavigationRequest('handleReset', ancestor)"
@@ -156,7 +156,6 @@ export default {
     data() {
         return {
             root: undefined,
-            initialLoad: false,
             isLoading: false,
             mainTreeHeight: undefined,
             searchLoading: false,
@@ -500,11 +499,6 @@ export default {
             this.ancestors = ancestors;
             this.childItems = children;
 
-            // track when FIRST full load of tree happens
-            if (!this.initialLoad) {
-                this.initialLoad = true;
-            }
-
             // any new items added or removed handled here
             this.composition.on('add', this.addChild);
             this.composition.on('remove', this.removeChild);

src/ui/layout/tree-item.vue

@@ -1,5 +1,6 @@
 <template>
 <div
+    ref="me"
     :style="{
         'top': virtualScroll ? itemTop : 'auto',
         'position': virtualScroll ? 'absolute' : 'relative'
@@ -10,14 +11,10 @@
         class="c-tree__item"
         :class="{
             'is-alias': isAlias,
-            'is-navigated-object': navigated,
-            'is-context-clicked': contextClickActive
+            'is-navigated-object': navigated
         }"
-        @click.capture="handleClick"
-        @contextmenu.capture="handleContextMenu"
     >
         <view-control
-            ref="navUp"
             v-model="expanded"
             class="c-tree__item__view-control"
             :control-class="'c-nav__up'"
@@ -25,15 +22,12 @@
             @input="resetTreeHere"
         />
         <object-label
-            ref="objectLabel"
             :domain-object="node.object"
             :object-path="node.objectPath"
             :navigate-to-path="navigationPath"
             :style="{ paddingLeft: leftOffset }"
-            @context-click-active="setContextClickActive"
         />
         <view-control
-            ref="navDown"
             v-model="expanded"
             class="c-tree__item__view-control"
             :control-class="'c-nav__down'"
@@ -97,8 +91,7 @@ export default {
         return {
             hasComposition: false,
             navigated: this.isNavigated(),
-            expanded: false,
-            contextClickActive: false
+            expanded: false
         };
     },
     computed: {
@@ -141,19 +134,6 @@ export default {
         this.openmct.router.off('change:path', this.highlightIfNavigated);
     },
     methods: {
-        handleClick(event) {
-            // skip for navigation, let viewControl handle click
-            if ([this.$refs.navUp.$el, this.$refs.navDown.$el].includes(event.target)) {
-                return;
-            }
-
-            event.stopPropagation();
-            this.$refs.objectLabel.navigateOrPreview(event);
-        },
-        handleContextMenu(event) {
-            event.stopPropagation();
-            this.$refs.objectLabel.showContextMenu(event);
-        },
         isNavigated() {
             return this.navigationPath === this.openmct.router.currentLocation.path;
         },
@@ -162,9 +142,6 @@ export default {
         },
         resetTreeHere() {
             this.$emit('resetTree', this.node);
-        },
-        setContextClickActive(active) {
-            this.contextClickActive = active;
         }
     }
 };

src/ui/mixins/context-menu-gesture.js

@@ -8,11 +8,6 @@ export default {
             }
         }
     },
-    data() {
-        return {
-            contextClickActive: false
-        };
-    },
     mounted() {
         //TODO: touch support
         this.$el.addEventListener('contextmenu', this.showContextMenu);
@@ -40,13 +35,7 @@ export default {
             let actions = actionsCollection.getVisibleActions();
             let sortedActions = this.openmct.actions._groupAndSortActions(actions);
 
-            this.openmct.menus.showMenu(event.clientX, event.clientY, sortedActions, this.onContextMenuDestroyed);
-            this.contextClickActive = true;
-            this.$emit('context-click-active', true);
-        },
-        onContextMenuDestroyed() {
-            this.contextClickActive = false;
-            this.$emit('context-click-active', false);
+            this.openmct.menus.showMenu(event.clientX, event.clientY, sortedActions);
         }
     }
 };

src/ui/preview/preview-header.vue

@@ -5,7 +5,7 @@
             class="l-browse-bar__object-name--w c-object-label"
         >
             <div class="c-object-label__type-icon"
-                 :class="type.definition.cssClass"
+                 :class="type.cssClass"
             ></div>
             <span class="l-browse-bar__object-name c-object-label__name">
                 {{ domainObject.name }}

src/ui/router/Browse.js

@@ -10,14 +10,12 @@ define([
         let unobserve = undefined;
         let currentObjectPath;
         let isRoutingInProgress = false;
-        let mutable;
 
         openmct.router.route(/^\/browse\/?$/, navigateToFirstChildOfRoot);
 
         openmct.router.route(/^\/browse\/(.*)$/, (path, results, params) => {
             isRoutingInProgress = true;
             let navigatePath = results[1];
-            clearMutationListeners();
             navigateToPath(navigatePath, params.view);
             onParamsChanged(null, null, params);
         });
@@ -38,25 +36,10 @@ define([
         }
 
         function viewObject(object, viewProvider) {
-            if (mutable) {
-                openmct.objects.destroyMutable(mutable);
-                mutable = undefined;
-            }
-
-            if (openmct.objects.supportsMutation(object)) {
-                mutable = openmct.objects._toMutable(object);
-            }
-
             currentObjectPath = openmct.router.path;
 
-            if (mutable !== undefined) {
-                openmct.layout.$refs.browseObject.show(mutable, viewProvider.key, true, currentObjectPath);
-                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.browseObject.show(object, viewProvider.key, true, currentObjectPath);
+            openmct.layout.$refs.browseBar.domainObject = object;
             openmct.layout.$refs.browseBar.viewKey = viewProvider.key;
         }
 
@@ -81,14 +64,23 @@ define([
                     return; // Prevent race.
                 }
 
-                objects = objects.reverse();
+                let navigatedObject = objects[objects.length - 1];
 
-                openmct.router.path = objects;
-                browseObject = objects[0];
+                // FIXME: this is a hack to support create action, intended to
+                // expose the current routed path.  We need to rewrite the
+                // navigation service and router to expose a clear and minimal
+                // API for this.
+                openmct.router.path = objects.reverse();
 
-                openmct.layout.$refs.browseBar.domainObject = browseObject;
+                unobserve = openmct.objects.observe(openmct.router.path[0], '*', (newObject) => {
+                    openmct.router.path[0] = newObject;
+                    browseObject = newObject;
+                });
 
-                if (!browseObject) {
+                openmct.layout.$refs.browseBar.domainObject = navigatedObject;
+                browseObject = navigatedObject;
+
+                if (!navigatedObject) {
                     openmct.layout.$refs.browseObject.clear();
 
                     return;
@@ -100,13 +92,13 @@ define([
 
                 document.title = browseObject.name; //change document title to current object in main view
 
-                if (currentProvider && currentProvider.canView(browseObject)) {
-                    viewObject(browseObject, currentProvider);
+                if (currentProvider && currentProvider.canView(navigatedObject)) {
+                    viewObject(navigatedObject, currentProvider);
 
                     return;
                 }
 
-                let defaultProvider = openmct.objectViews.get(browseObject)[0];
+                let defaultProvider = openmct.objectViews.get(navigatedObject)[0];
                 if (defaultProvider) {
                     openmct.router.updateParams({
                         view: defaultProvider.key
@@ -122,13 +114,7 @@ define([
 
         function pathToObjects(path) {
             return Promise.all(path.map((keyString) => {
-                let identifier = openmct.objects.parseKeyString(keyString);
-
-                if (openmct.objects.supportsMutation(identifier)) {
-                    return openmct.objects.getMutable(identifier);
-                } else {
-                    return openmct.objects.get(identifier);
-                }
+                return openmct.objects.get(keyString);
             }));
         }
 
@@ -146,15 +132,5 @@ define([
                     });
             });
         }
-
-        function clearMutationListeners() {
-            if (openmct.router.path !== undefined) {
-                openmct.router.path.forEach((pathObject) => {
-                    if (pathObject.isMutable) {
-                        openmct.objects.destroyMutable(pathObject);
-                    }
-                });
-            }
-        }
     };
 });

src/utils/testing.js

@@ -90,28 +90,6 @@ export function resetApplicationState(openmct) {
     return promise;
 }
 
-// required: key
-// optional: element, keyCode, type
-export function simulateKeyEvent(opts) {
-
-    if (!opts.key) {
-        console.warn('simulateKeyEvent needs a key');
-
-        return;
-    }
-
-    const el = opts.element || document;
-    const key = opts.key;
-    const keyCode = opts.keyCode || key;
-    const type = opts.type || 'keydown';
-    const event = new Event(type);
-
-    event.keyCode = keyCode;
-    event.key = key;
-
-    el.dispatchEvent(event);
-}
-
 function clearBuiltinSpy(funcDefinition) {
     funcDefinition.object[funcDefinition.functionName] = funcDefinition.nativeFunction;
 }