Fix broken test

* Removed local storage of navigated path in tree
Co-authored-by: Deep Tailor <deep.j.tailor@nasa.com>

.eslintrc.js

@@ -54,7 +54,7 @@ module.exports = {
             {
                 "anonymous": "always",
                 "asyncArrow": "always",
-                "named": "never",
+                "named": "never"
             }
         ],
         "array-bracket-spacing": "error",
@@ -178,7 +178,10 @@ module.exports = {
         //https://eslint.org/docs/rules/no-whitespace-before-property
         "no-whitespace-before-property": "error",
         // https://eslint.org/docs/rules/object-curly-newline
-        "object-curly-newline": ["error", {"consistent": true, "multiline": true}],
+        "object-curly-newline": ["error", {
+            "consistent": true,
+            "multiline": true
+        }],
         // https://eslint.org/docs/rules/object-property-newline
         "object-property-newline": "error",
         // https://eslint.org/docs/rules/brace-style
@@ -188,7 +191,7 @@ module.exports = {
         // https://eslint.org/docs/rules/operator-linebreak
         "operator-linebreak": ["error", "before", {"overrides": {"=": "after"}}],
         // https://eslint.org/docs/rules/padding-line-between-statements
-        "padding-line-between-statements":["error", {
+        "padding-line-between-statements": ["error", {
             "blankLine": "always",
             "prev": "multiline-block-like",
             "next": "*"
@@ -200,11 +203,17 @@ module.exports = {
         // https://eslint.org/docs/rules/space-infix-ops
         "space-infix-ops": "error",
         // https://eslint.org/docs/rules/space-unary-ops
-        "space-unary-ops": ["error", {"words": true, "nonwords": false}],
+        "space-unary-ops": ["error", {
+            "words": true,
+            "nonwords": false
+        }],
         // https://eslint.org/docs/rules/arrow-spacing
         "arrow-spacing": "error",
         // https://eslint.org/docs/rules/semi-spacing
-        "semi-spacing": ["error", {"before": false, "after": true}],
+        "semi-spacing": ["error", {
+            "before": false,
+            "after": true
+        }],
 
         "vue/html-indent": [
             "error",
@@ -237,6 +246,7 @@ module.exports = {
         }],
         "vue/multiline-html-element-content-newline": "off",
         "vue/singleline-html-element-content-newline": "off",
+        "vue/no-mutating-props": "off"
 
     },
     "overrides": [

example/styleguide/bundle.js

@@ -138,7 +138,7 @@ define([
                     "id": "styleguide:home",
                     "priority": "preferred",
                     "model": {
-                        "type": "folder",
+                        "type": "noneditable.folder",
                         "name": "Style Guide Home",
                         "location": "ROOT",
                         "composition": [
@@ -155,7 +155,7 @@ define([
                     "id": "styleguide:ui-elements",
                     "priority": "preferred",
                     "model": {
-                        "type": "folder",
+                        "type": "noneditable.folder",
                         "name": "UI Elements",
                         "location": "styleguide:home",
                         "composition": [

karma.conf.js

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

package.json

@@ -1,6 +1,6 @@
 {
   "name": "openmct",
-  "version": "1.5.0-SNAPSHOT",
+  "version": "1.6.2-SNAPSHOT",
   "description": "The Open MCT core platform",
   "dependencies": {},
   "devDependencies": {
@@ -23,7 +23,7 @@
     "d3-time": "1.0.x",
     "d3-time-format": "2.1.x",
     "eslint": "7.0.0",
-    "eslint-plugin-vue": "^6.0.0",
+    "eslint-plugin-vue": "^7.5.0",
     "eslint-plugin-you-dont-need-lodash-underscore": "^6.10.0",
     "eventemitter3": "^1.2.0",
     "exports-loader": "^0.7.0",

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 newStyleObject = objectUtils.toNewFormat(domainObject, domainObject.getId());
+                let identifier = this.openmct.objects.parseKeyString(domainObject.getId());
 
-                return this.openmct.objects.isPersistable(newStyleObject);
+                return this.openmct.objects.isPersistable(identifier);
             }
 
             return true;

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

@@ -43,7 +43,8 @@ define(
                 );
 
                 mockObjectAPI = jasmine.createSpyObj('objectAPI', [
-                    'isPersistable'
+                    'isPersistable',
+                    'parseKeyString'
                 ]);
 
                 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 newStyleObject = objectUtils.toNewFormat(parent, parent.getId());
+                let identifier = this.openmct.objects.parseKeyString(parent.getId());
 
-                return this.openmct.objects.isPersistable(newStyleObject);
+                return this.openmct.objects.isPersistable(identifier);
             }
 
             return true;

platform/containment/test/PersistableCompositionPolicySpec.js

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

platform/search/src/services/BareBonesSearchWorker.js

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

platform/search/src/services/GenericSearchProvider.js

@@ -125,13 +125,12 @@ define([
      * @param topic the topicService.
      */
     GenericSearchProvider.prototype.indexOnMutation = function (topic) {
-        var mutationTopic = topic('mutation'),
-            provider = this;
+        let mutationTopic = topic('mutation');
 
-        mutationTopic.listen(function (mutatedObject) {
-            var editor = mutatedObject.getCapability('editor');
+        mutationTopic.listen(mutatedObject => {
+            let editor = mutatedObject.getCapability('editor');
             if (!editor || !editor.inEditContext()) {
-                provider.index(
+                this.index(
                     mutatedObject.getId(),
                     mutatedObject.getModel()
                 );
@@ -147,10 +146,15 @@ define([
      * @param {String} id to be indexed.
      */
     GenericSearchProvider.prototype.scheduleForIndexing = function (id) {
-        if (!this.indexedIds[id] && !this.pendingIndex[id]) {
-            this.indexedIds[id] = true;
-            this.pendingIndex[id] = true;
-            this.idsToIndex.push(id);
+        const identifier = objectUtils.parseKeyString(id);
+        const objectProvider = this.openmct.objects.getProvider(identifier);
+
+        if (objectProvider === undefined || objectProvider.search === undefined) {
+            if (!this.indexedIds[id] && !this.pendingIndex[id]) {
+                this.indexedIds[id] = true;
+                this.pendingIndex[id] = true;
+                this.idsToIndex.push(id);
+            }
         }
 
         this.keepIndexing();
@@ -262,6 +266,7 @@ define([
                 return {
                     id: hit.item.id,
                     model: hit.item.model,
+                    type: hit.item.type,
                     score: hit.matchCount
                 };
             });

platform/search/src/services/GenericSearchWorker.js

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

src/MCT.js

@@ -219,7 +219,7 @@ define([
          * @memberof module:openmct.MCT#
          * @name objects
          */
-        this.objects = new api.ObjectAPI();
+        this.objects = new api.ObjectAPI.default(this.types, this);
 
         /**
          * An interface for retrieving and interpreting telemetry data associated
@@ -283,6 +283,7 @@ define([
         this.install(this.plugins.NewFolderAction());
         this.install(this.plugins.ViewDatumAction());
         this.install(this.plugins.ObjectInterceptors());
+        this.install(this.plugins.NonEditableFolder());
     }
 
     MCT.prototype = Object.create(EventEmitter.prototype);
@@ -371,7 +372,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.plugins.DisplayLayout._installed) {
+        if (this.types.get('layout') === undefined) {
             this.install(this.plugins.DisplayLayout({
                 showAsView: ['summary-widget']
             }));

src/adapter/services/LegacyObjectAPIInterceptor.js

@@ -61,6 +61,7 @@ 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);
@@ -138,6 +139,12 @@ define([
             });
     };
 
+    ObjectServiceProvider.prototype.superSecretFallbackSearch = function (query, options) {
+        const searchService = this.$injector.get('searchService');
+
+        return searchService.query(query);
+    };
+
     // Injects new object API as a decorator so that it hijacks all requests.
     // Object providers implemented on new API should just work, old API should just work, many things may break.
     function LegacyObjectAPIInterceptor(openmct, ROOTS, instantiate, topic, objectService) {

src/api/actions/ActionCollectionSpec.js

@@ -50,6 +50,10 @@ describe('The ActionCollection', () => {
                 }
             }
         ];
+        openmct.objects.addProvider('', jasmine.createSpyObj('mockMutableObjectProvider', [
+            'create',
+            'update'
+        ]));
         mockView = {
             getViewContext: () => {
                 return {

src/api/composition/CompositionCollection.js

@@ -60,6 +60,17 @@ 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();
+            });
+        }
     }
 
     /**
@@ -75,10 +86,6 @@ 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(
@@ -189,6 +196,13 @@ define([
 
             this.provider.add(this.domainObject, child.identifier);
         } else {
+            if (this.returnMutables && this.publicAPI.objects.supportsMutation(child.identifier)) {
+                let keyString = this.publicAPI.objects.makeKeyString(child.identifier);
+
+                child = this.publicAPI.objects._toMutable(child);
+                this.mutables[keyString] = child;
+            }
+
             this.emit('add', child);
         }
     };
@@ -202,6 +216,8 @@ 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)));
@@ -234,6 +250,14 @@ 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);
         }
     };
@@ -281,12 +305,6 @@ 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();
@@ -308,5 +326,11 @@ 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) {
+    showMenu(x, y, actions, onDestroy) {
         if (this.menuComponent) {
             this.menuComponent.dismiss();
         }
@@ -46,7 +46,8 @@ class MenuAPI {
         let options = {
             x,
             y,
-            actions
+            actions,
+            onDestroy
         };
 
         this.menuComponent = new Menu(options);

src/api/menu/MenuAPISpec.js

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

src/api/menu/menu.js

@@ -30,12 +30,12 @@ class Menu extends EventEmitter {
         this.options = options;
 
         this.component = new Vue({
-            provide: {
-                actions: options.actions
-            },
             components: {
                 MenuComponent
             },
+            provide: {
+                actions: options.actions
+            },
             template: '<menu-component />'
         });
 

src/api/notifications/NotificationAPI.js

@@ -75,13 +75,20 @@ export default class NotificationAPI extends EventEmitter {
      * Info notifications are low priority informational messages for the user. They will be auto-destroy after a brief
      * period of time.
      * @param {string} message The message to display to the user
+     * @param {Object} [options] object with following properties
+     *      autoDismissTimeout: {number} in miliseconds to automatically dismisses notification
+     *      link: {Object} Add a link to notifications for navigation
+     *              onClick: callback function
+     *              cssClass: css class name to add style on link
+     *              text: text to display for link
      * @returns {InfoNotification}
      */
-    info(message) {
+    info(message, options = {}) {
         let notificationModel = {
             message: message,
             autoDismiss: true,
-            severity: "info"
+            severity: "info",
+            options
         };
 
         return this._notify(notificationModel);
@@ -90,12 +97,19 @@ export default class NotificationAPI extends EventEmitter {
     /**
      * Present an alert to the user.
      * @param {string} message The message to display to the user.
+     * @param {Object} [options] object with following properties
+     *      autoDismissTimeout: {number} in miliseconds to automatically dismisses notification
+     *      link: {Object} Add a link to notifications for navigation
+     *              onClick: callback function
+     *              cssClass: css class name to add style on link
+     *              text: text to display for link
      * @returns {Notification}
      */
-    alert(message) {
+    alert(message, options = {}) {
         let notificationModel = {
             message: message,
-            severity: "alert"
+            severity: "alert",
+            options
         };
 
         return this._notify(notificationModel);
@@ -104,12 +118,19 @@ export default class NotificationAPI extends EventEmitter {
     /**
      * Present an error message to the user
      * @param {string} message
+     * @param {Object} [options] object with following properties
+     *      autoDismissTimeout: {number} in miliseconds to automatically dismisses notification
+     *      link: {Object} Add a link to notifications for navigation
+     *              onClick: callback function
+     *              cssClass: css class name to add style on link
+     *              text: text to display for link
      * @returns {Notification}
      */
-    error(message) {
+    error(message, options = {}) {
         let notificationModel = {
             message: message,
-            severity: "error"
+            severity: "error",
+            options
         };
 
         return this._notify(notificationModel);
@@ -325,9 +346,11 @@ export default class NotificationAPI extends EventEmitter {
         this.emit('notification', notification);
 
         if (notification.model.autoDismiss || this._selectNextNotification()) {
+            const autoDismissTimeout = notification.model.options.autoDismissTimeout
+                || DEFAULT_AUTO_DISMISS_TIMEOUT;
             this.activeTimeout = setTimeout(() => {
                 this._dismissOrMinimize(notification);
-            }, DEFAULT_AUTO_DISMISS_TIMEOUT);
+            }, autoDismissTimeout);
         } else {
             delete this.activeTimeout;
         }

src/api/notifications/NotificationAPISpec.js

@@ -0,0 +1,154 @@
+/*****************************************************************************
+ * 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

@@ -0,0 +1,147 @@
+/*****************************************************************************
+ * 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.
+    }
+
+    $refresh(model) {
+        //TODO: Currently we are updating the entire object.
+        // In the future we could update a specific property of the object using the 'path' parameter.
+        this._globalEventEmitter.emit(qualifiedEventName(this, '$_synchronize_model'), model);
+
+        //Emit wildcard event, with path so that callback knows what changed
+        this._globalEventEmitter.emit(qualifiedEventName(this, '*'), this);
+    }
+
+    $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

@@ -1,102 +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.
- *****************************************************************************/
-
-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,365 +20,490 @@
  * at runtime from the About dialog for additional information.
  *****************************************************************************/
 
-define([
-    'lodash',
-    'objectUtils',
-    './MutableObject',
-    './RootRegistry',
-    './RootObjectProvider',
-    './InterceptorRegistry',
-    'EventEmitter'
-], function (
-    _,
-    utils,
-    MutableObject,
-    RootRegistry,
-    RootObjectProvider,
-    InterceptorRegistry,
-    EventEmitter
-) {
+import utils from 'objectUtils';
+import MutableDomainObject from './MutableDomainObject';
+import RootRegistry from './RootRegistry';
+import RootObjectProvider from './RootObjectProvider';
+import EventEmitter from 'EventEmitter';
+import InterceptorRegistry from './InterceptorRegistry';
 
-    /**
-     * 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() {
-        this.eventEmitter = new EventEmitter();
-        this.providers = {};
-        this.rootRegistry = new RootRegistry();
-        this.rootProvider = new RootObjectProvider.default(this.rootRegistry);
-        this.cache = {};
-        this.interceptorRegistry = new InterceptorRegistry.default();
+function ObjectAPI(typeRegistry, openmct) {
+    this.typeRegistry = typeRegistry;
+    this.eventEmitter = new EventEmitter();
+    this.providers = {};
+    this.rootRegistry = new RootRegistry();
+    this.injectIdentifierService = function () {
+        this.identifierService = openmct.$injector.get("identifierService");
+    };
+
+    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;
+};
+
+/**
+ * @private
+ */
+ObjectAPI.prototype.getIdentifierService = function () {
+    // Lazily acquire identifier service
+    if (!this.identifierService) {
+        this.injectIdentifierService();
     }
 
-    /**
-     * Set fallback provider, this is an internal API for legacy reasons.
-     * @private
-     */
-    ObjectAPI.prototype.supersecretSetFallbackProvider = function (p) {
-        this.fallbackProvider = p;
-    };
+    return this.identifierService;
+};
 
-    /**
-     * Retrieve the provider for a given identifier.
-     * @private
-     */
-    ObjectAPI.prototype.getProvider = function (identifier) {
-        if (identifier.key === 'ROOT') {
-            return this.rootProvider;
-        }
+/**
+ * Retrieve the provider for a given identifier.
+ * @private
+ */
+ObjectAPI.prototype.getProvider = function (identifier) {
+    //handles the '' vs 'mct' namespace issue
+    const keyString = utils.makeKeyString(identifier);
+    const identifierService = this.getIdentifierService();
+    const namespace = identifierService.parse(keyString).getSpace();
 
-        return this.providers[identifier.namespace] || this.fallbackProvider;
-    };
+    if (identifier.key === 'ROOT') {
+        return this.rootProvider;
+    }
 
-    /**
-     * Get the root-level object.
-     * @returns {Promise.<DomainObject>} a promise for the root object
-     */
-    ObjectAPI.prototype.getRoot = function () {
-        return this.rootProvider.get();
-    };
+    return this.providers[namespace] || this.fallbackProvider;
+};
 
-    /**
-     * 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;
-    };
+/**
+ * Get the root-level object.
+ * @returns {Promise.<DomainObject>} a promise for the root object
+ */
+ObjectAPI.prototype.getRoot = function () {
+    return this.rootProvider.get();
+};
 
-    /**
-     * 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
-     */
+/**
+ * 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;
+};
 
-    /**
-     * 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
-     */
+/**
+ * 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
+ */
 
-    /**
-     * 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
-     */
+/**
+ * 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
+ */
 
-    /**
-     * 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
-     */
+/**
+ * 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
+ */
 
-    /**
-     * 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
-     */
+/**
+ * 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
+ */
 
-    /**
-     * 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];
-        }
+/**
+ * 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
+ */
 
-        identifier = utils.parseKeyString(identifier);
-        const provider = this.getProvider(identifier);
+ObjectAPI.prototype.get = function (identifier) {
+    let keystring = this.makeKeyString(identifier);
+    if (this.cache[keystring] !== undefined) {
+        return this.cache[keystring];
+    }
 
-        if (!provider) {
-            throw new Error('No Provider Matched');
-        }
+    identifier = utils.parseKeyString(identifier);
+    const provider = this.getProvider(identifier);
 
-        if (!provider.get) {
-            throw new Error('Provider does not support get!');
-        }
+    if (!provider) {
+        throw new Error('No Provider Matched');
+    }
 
-        let objectPromise = provider.get(identifier);
+    if (!provider.get) {
+        throw new Error('Provider does not support get!');
+    }
 
-        this.cache[keystring] = objectPromise;
+    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;
+    return objectPromise.then(result => {
+        delete this.cache[keystring];
+        const interceptors = this.listGetInterceptors(identifier, result);
+        interceptors.forEach(interceptor => {
+            result = interceptor.invoke(identifier, 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;
-    };
+    });
+};
 
-    /**
-     * 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);
-    };
+/**
+ * Search for domain objects.
+ *
+ * Object providersSearches and combines results of each object provider search.
+ * Objects without search provided will have been indexed
+ * and will be searched using the fallback indexed search.
+ * Search results are asynchronous and resolve in parallel.
+ *
+ * @method search
+ * @memberof module:openmct.ObjectAPI#
+ * @param {string} query the term to search for
+ * @param {Object} options search options
+ * @returns {Array.<Promise.<module:openmct.DomainObject>>}
+ *          an array of promises returned from each object provider's search function
+ *          each resolving to domain objects matching provided search query and options.
+ */
+ObjectAPI.prototype.search = function (query, options) {
+    const searchPromises = Object.values(this.providers)
+        .filter(provider => provider.search !== undefined)
+        .map(provider => provider.search(query, options));
 
-    /**
-     * 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);
+    searchPromises.push(this.fallbackProvider.superSecretFallbackSearch(query, options)
+        .then(results => results.hits
+            .map(hit => utils.toNewFormat(hit.object.getModel(), hit.object.getId()))));
 
-        return mutableObject.set(path, value);
-    };
+    return searchPromises;
+};
 
-    /**
-     * 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);
-
-        return mutableObject.stopListening.bind(mutableObject);
-    };
-
-    /**
-     * @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);
-    };
-
-    /**
-     * 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);
-            });
-    };
-
-    ObjectAPI.prototype.getOriginalPath = function (identifier, path = []) {
-        return this.get(identifier).then((domainObject) => {
-            path.push(domainObject);
-            let location = domainObject.location;
-
-            if (location) {
-                return this.getOriginalPath(utils.parseKeyString(location), path);
-            } else {
-                return path;
-            }
-        });
-    };
-
-    /**
-     * 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);
-    };
-
-    /**
-     * 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
-     */
-
-    function hasAlreadyBeenPersisted(domainObject) {
-        return domainObject.persisted !== undefined
-            && domainObject.persisted === domainObject.modified;
+/**
+ * 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 (idOrKeyString) {
+    if (!this.supportsMutation(idOrKeyString)) {
+        throw new Error(`Object "${this.makeKeyString(idOrKeyString)}" does not support mutation.`);
     }
 
-    return ObjectAPI;
-});
+    return this.get(idOrKeyString).then((object) => {
+        const mutableDomainObject = this._toMutable(object);
+
+        // Check if provider supports realtime updates
+        let identifier = utils.parseKeyString(idOrKeyString);
+        let provider = this.getProvider(identifier);
+
+        if (provider !== undefined
+            && provider.observe !== undefined) {
+            let unobserve = provider.observe(identifier, (updatedModel) => {
+                mutableDomainObject.$refresh(updatedModel);
+            });
+            mutableDomainObject.$on('$destroy', () => {
+                unobserve();
+            });
+        }
+
+        return mutableDomainObject;
+    });
+};
+
+/**
+ * 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");
+    }
+};
+
+ObjectAPI.prototype.delete = function () {
+    throw new Error('Delete not implemented');
+};
+
+ObjectAPI.prototype.isPersistable = function (idOrKeyString) {
+    let identifier = utils.parseKeyString(idOrKeyString);
+    let provider = this.getProvider(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.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;
+            });
+            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;
+};
+
+/**
+ * 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);
+        });
+};
+
+ObjectAPI.prototype.getOriginalPath = function (identifier, path = []) {
+    return this.get(identifier).then((domainObject) => {
+        path.push(domainObject);
+        let location = domainObject.location;
+
+        if (location) {
+            return this.getOriginalPath(utils.parseKeyString(location), path);
+        } else {
+            return path;
+        }
+    });
+};
+
+/**
+ * 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
+ */
+
+function hasAlreadyBeenPersisted(domainObject) {
+    return domainObject.persisted !== undefined
+        && domainObject.persisted === domainObject.modified;
+}
+
+export default ObjectAPI;

src/api/objects/ObjectAPISearchSpec.js

@@ -0,0 +1,119 @@
+import ObjectAPI from './ObjectAPI.js';
+
+describe("The Object API Search Function", () => {
+    const MOCK_PROVIDER_KEY = 'mockProvider';
+    const ANOTHER_MOCK_PROVIDER_KEY = 'anotherMockProvider';
+    const MOCK_PROVIDER_SEARCH_DELAY = 15000;
+    const ANOTHER_MOCK_PROVIDER_SEARCH_DELAY = 20000;
+    const TOTAL_TIME_ELAPSED = 21000;
+    const BASE_TIME = new Date(2021, 0, 1);
+
+    let objectAPI;
+    let mockObjectProvider;
+    let anotherMockObjectProvider;
+    let mockFallbackProvider;
+    let fallbackProviderSearchResults;
+    let resultsPromises;
+
+    beforeEach(() => {
+        jasmine.clock().install();
+        jasmine.clock().mockDate(BASE_TIME);
+
+        resultsPromises = [];
+        fallbackProviderSearchResults = {
+            hits: []
+        };
+
+        objectAPI = new ObjectAPI();
+
+        mockObjectProvider = jasmine.createSpyObj("mock object provider", [
+            "search"
+        ]);
+        anotherMockObjectProvider = jasmine.createSpyObj("another mock object provider", [
+            "search"
+        ]);
+        mockFallbackProvider = jasmine.createSpyObj("super secret fallback provider", [
+            "superSecretFallbackSearch"
+        ]);
+        objectAPI.addProvider('objects', mockObjectProvider);
+        objectAPI.addProvider('other-objects', anotherMockObjectProvider);
+        objectAPI.supersecretSetFallbackProvider(mockFallbackProvider);
+
+        mockObjectProvider.search.and.callFake(() => {
+            return new Promise(resolve => {
+                const mockProviderSearch = {
+                    name: MOCK_PROVIDER_KEY,
+                    start: new Date()
+                };
+
+                setTimeout(() => {
+                    mockProviderSearch.end = new Date();
+
+                    return resolve(mockProviderSearch);
+                }, MOCK_PROVIDER_SEARCH_DELAY);
+            });
+        });
+        anotherMockObjectProvider.search.and.callFake(() => {
+            return new Promise(resolve => {
+                const anotherMockProviderSearch = {
+                    name: ANOTHER_MOCK_PROVIDER_KEY,
+                    start: new Date()
+                };
+
+                setTimeout(() => {
+                    anotherMockProviderSearch.end = new Date();
+
+                    return resolve(anotherMockProviderSearch);
+                }, ANOTHER_MOCK_PROVIDER_SEARCH_DELAY);
+            });
+        });
+        mockFallbackProvider.superSecretFallbackSearch.and.callFake(
+            () => new Promise(
+                resolve => setTimeout(
+                    () => resolve(fallbackProviderSearchResults),
+                    50
+                )
+            )
+        );
+
+        resultsPromises = objectAPI.search('foo');
+
+        jasmine.clock().tick(TOTAL_TIME_ELAPSED);
+    });
+
+    afterEach(() => {
+        jasmine.clock().uninstall();
+    });
+
+    it("uses each objects given provider's search function", () => {
+        expect(mockObjectProvider.search).toHaveBeenCalled();
+        expect(anotherMockObjectProvider.search).toHaveBeenCalled();
+    });
+
+    it("uses the fallback indexed search for objects without a search function provided", () => {
+        expect(mockFallbackProvider.superSecretFallbackSearch).toHaveBeenCalled();
+    });
+
+    it("provides each providers results as promises that resolve in parallel", async () => {
+        const results = await Promise.all(resultsPromises);
+        const mockProviderResults = results.find(
+            result => result.name === MOCK_PROVIDER_KEY
+        );
+        const anotherMockProviderResults = results.find(
+            result => result.name === ANOTHER_MOCK_PROVIDER_KEY
+        );
+        const mockProviderStart = mockProviderResults.start.getTime();
+        const mockProviderEnd = mockProviderResults.end.getTime();
+        const anotherMockProviderStart = anotherMockProviderResults.start.getTime();
+        const anotherMockProviderEnd = anotherMockProviderResults.end.getTime();
+        const searchElapsedTime = Math.max(mockProviderEnd, anotherMockProviderEnd)
+            - Math.min(mockProviderEnd, anotherMockProviderEnd);
+
+        expect(mockProviderStart).toBeLessThan(anotherMockProviderEnd);
+        expect(anotherMockProviderStart).toBeLessThan(mockProviderEnd);
+        expect(searchElapsedTime).toBeLessThan(
+            MOCK_PROVIDER_SEARCH_DELAY
+            + ANOTHER_MOCK_PROVIDER_SEARCH_DELAY
+        );
+    });
+});

src/api/objects/ObjectAPISpec.js

@@ -2,12 +2,30 @@ import ObjectAPI from './ObjectAPI.js';
 
 describe("The Object API", () => {
     let objectAPI;
+    let typeRegistry;
+    let openmct = {};
+    let mockIdentifierService;
     let mockDomainObject;
     const TEST_NAMESPACE = "test-namespace";
     const FIFTEEN_MINUTES = 15 * 60 * 1000;
 
     beforeEach(() => {
-        objectAPI = new ObjectAPI();
+        typeRegistry = jasmine.createSpyObj('typeRegistry', [
+            'get'
+        ]);
+        openmct.$injector = jasmine.createSpyObj('$injector', ['get']);
+        mockIdentifierService = jasmine.createSpyObj(
+            'identifierService',
+            ['parse']
+        );
+        mockIdentifierService.parse.and.returnValue({
+            getSpace: () => {
+                return TEST_NAMESPACE;
+            }
+        });
+
+        openmct.$injector.get.and.returnValue(mockIdentifierService);
+        objectAPI = new ObjectAPI(typeRegistry, openmct);
         mockDomainObject = {
             identifier: {
                 namespace: TEST_NAMESPACE,
@@ -33,6 +51,7 @@ 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", () => {
@@ -128,4 +147,155 @@ describe("The Object API", () => {
             });
         });
     });
+
+    describe("the mutation API", () => {
+        let testObject;
+        let updatedTestObject;
+        let mutable;
+        let mockProvider;
+        let callbacks = [];
+
+        beforeEach(function () {
+            objectAPI = new ObjectAPI(typeRegistry, openmct);
+            testObject = {
+                identifier: {
+                    namespace: TEST_NAMESPACE,
+                    key: 'test-key'
+                },
+                name: 'test object',
+                otherAttribute: 'other-attribute-value',
+                objectAttribute: {
+                    embeddedObject: {
+                        embeddedKey: 'embedded-value'
+                    }
+                }
+            };
+            updatedTestObject = Object.assign({otherAttribute: 'changed-attribute-value'}, testObject);
+            mockProvider = jasmine.createSpyObj("mock provider", [
+                "get",
+                "create",
+                "update",
+                "observe",
+                "observeObjectChanges"
+            ]);
+            mockProvider.get.and.returnValue(Promise.resolve(testObject));
+            mockProvider.observeObjectChanges.and.callFake(() => {
+                callbacks[0](updatedTestObject);
+                callbacks.splice(0, 1);
+            });
+            mockProvider.observe.and.callFake((id, callback) => {
+                if (callbacks.length === 0) {
+                    callbacks.push(callback);
+                } else {
+                    callbacks[0] = callback;
+                }
+            });
+
+            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));
+            });
+
+            it('that observes for object changes', function () {
+                let mockListener = jasmine.createSpy('mockListener');
+                objectAPI.observe(testObject, '*', mockListener);
+                mockProvider.observeObjectChanges();
+                expect(mockListener).toHaveBeenCalled();
+            });
+        });
+
+        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/api/objects/RootRegistry.js

@@ -48,7 +48,7 @@ define([
             this.providers.push(function () {
                 return key;
             });
-        } else if (_.isFunction(key)) {
+        } else if (typeof key === "function") {
             this.providers.push(key);
         }
     };

src/api/overlays/Dialog.js

@@ -6,6 +6,9 @@ class Dialog extends Overlay {
     constructor({iconClass, message, title, hint, timestamp, ...options}) {
 
         let component = new Vue({
+            components: {
+                DialogComponent: DialogComponent
+            },
             provide: {
                 iconClass,
                 message,
@@ -13,9 +16,6 @@ class Dialog extends Overlay {
                 hint,
                 timestamp
             },
-            components: {
-                DialogComponent: DialogComponent
-            },
             template: '<dialog-component></dialog-component>'
         }).$mount();
 

src/api/overlays/ProgressDialog.js

@@ -7,6 +7,9 @@ let component;
 class ProgressDialog extends Overlay {
     constructor({progressPerc, progressText, iconClass, message, title, hint, timestamp, ...options}) {
         component = new Vue({
+            components: {
+                ProgressDialogComponent: ProgressDialogComponent
+            },
             provide: {
                 iconClass,
                 message,
@@ -14,9 +17,6 @@ class ProgressDialog extends Overlay {
                 hint,
                 timestamp
             },
-            components: {
-                ProgressDialogComponent: ProgressDialogComponent
-            },
             data() {
                 return {
                     model: {

src/api/overlays/components/OverlayComponent.vue

@@ -38,12 +38,12 @@
 
 <script>
 export default {
+    inject: ['dismiss', 'element', 'buttons', 'dismissable'],
     data: function () {
         return {
             focusIndex: -1
         };
     },
-    inject: ['dismiss', 'element', 'buttons', 'dismissable'],
     mounted() {
         const element = this.$refs.element;
         element.appendChild(this.element);

src/plugins/CouchDBSearchFolder/plugin.js

@@ -0,0 +1,37 @@
+export default function (couchPlugin, searchFilter) {
+    return function install(openmct) {
+        const couchProvider = couchPlugin.couchProvider;
+
+        openmct.objects.addRoot({
+            namespace: 'couch-search',
+            key: 'couch-search'
+        });
+
+        openmct.objects.addProvider('couch-search', {
+            get(identifier) {
+                if (identifier.key !== 'couch-search') {
+                    return undefined;
+                } else {
+                    return Promise.resolve({
+                        identifier,
+                        type: 'folder',
+                        name: "CouchDB Documents"
+                    });
+                }
+            }
+        });
+
+        openmct.composition.addProvider({
+            appliesTo(domainObject) {
+                return domainObject.identifier.namespace === 'couch-search'
+                    && domainObject.identifier.key === 'couch-search';
+            },
+            load() {
+                return couchProvider.getObjectsByFilter(searchFilter).then(objects => {
+                    return objects.map(object => object.identifier);
+                });
+            }
+        });
+    };
+
+}

src/plugins/CouchDBSearchFolder/pluginSpec.js

@@ -0,0 +1,91 @@
+/*****************************************************************************
+ * 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";
+import CouchDBSearchFolderPlugin from './plugin';
+
+describe('the plugin', function () {
+    let identifier = {
+        namespace: 'couch-search',
+        key: "couch-search"
+    };
+    let testPath = '/test/db';
+    let openmct;
+    let composition;
+
+    beforeEach((done) => {
+
+        openmct = createOpenMct();
+
+        let couchPlugin = openmct.plugins.CouchDB(testPath);
+        openmct.install(couchPlugin);
+
+        openmct.install(new CouchDBSearchFolderPlugin(couchPlugin, {
+            "selector": {
+                "model": {
+                    "type": "plan"
+                }
+            }
+        }));
+
+        openmct.on('start', done);
+        openmct.startHeadless();
+
+        composition = openmct.composition.get({identifier});
+
+        spyOn(couchPlugin.couchProvider, 'getObjectsByFilter').and.returnValue(Promise.resolve([
+            {
+                identifier: {
+                    key: "1",
+                    namespace: "mct"
+                }
+            },
+            {
+                identifier: {
+                    key: "2",
+                    namespace: "mct"
+                }
+            }
+        ]));
+    });
+
+    afterEach(() => {
+        return resetApplicationState(openmct);
+    });
+
+    it('provides a folder to hold plans', () => {
+        openmct.objects.get(identifier).then((object) => {
+            expect(object).toEqual({
+                identifier,
+                type: 'folder',
+                name: "CouchDB Documents"
+            });
+        });
+    });
+
+    it('provides composition for couch search folders', () => {
+        composition.load().then((objects) => {
+            expect(objects.length).toEqual(2);
+        });
+    });
+
+});

src/plugins/LADTable/LADTableViewProvider.js

@@ -44,11 +44,15 @@ export default function LADTableViewProvider(openmct) {
                             LadTableComponent: LadTable
                         },
                         provide: {
-                            openmct,
-                            domainObject,
-                            objectPath
+                            openmct
                         },
-                        template: '<lad-table-component></lad-table-component>'
+                        data: () => {
+                            return {
+                                domainObject,
+                                objectPath
+                            };
+                        },
+                        template: '<lad-table-component :domain-object="domainObject" :object-path="objectPath"></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">{{ name }}</td>
+    <td class="js-first-data">{{ domainObject.name }}</td>
     <td class="js-second-data">{{ formattedTimestamp }}</td>
     <td
         class="js-third-data"
@@ -50,12 +50,16 @@ const CONTEXT_MENU_ACTIONS = [
 ];
 
 export default {
-    inject: ['openmct', 'objectPath'],
+    inject: ['openmct'],
     props: {
         domainObject: {
             type: Object,
             required: true
         },
+        objectPath: {
+            type: Array,
+            required: true
+        },
         hasUnits: {
             type: Boolean,
             requred: true
@@ -66,7 +70,6 @@ export default {
         currentObjectPath.unshift(this.domainObject);
 
         return {
-            name: this.domainObject.name,
             timestamp: undefined,
             value: '---',
             valueClass: '',
@@ -89,14 +92,6 @@ 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);
 
@@ -119,7 +114,6 @@ export default {
         }
     },
     destroyed() {
-        this.stopWatchingMutation();
         this.unsubscribe();
         this.openmct.time.off('timeSystem', this.updateTimeSystem);
         this.openmct.time.off('bounds', this.updateBounds);
@@ -160,9 +154,6 @@ 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,6 +36,7 @@
                 v-for="item in items"
                 :key="item.key"
                 :domain-object="item.domainObject"
+                :object-path="objectPath"
                 :has-units="hasUnits"
             />
         </tbody>
@@ -47,10 +48,20 @@
 import LadRow from './LADRow.vue';
 
 export default {
-    inject: ['openmct', 'domainObject', 'objectPath'],
     components: {
         LadRow
     },
+    inject: ['openmct'],
+    props: {
+        domainObject: {
+            type: Object,
+            required: true
+        },
+        objectPath: {
+            type: Array,
+            required: true
+        }
+    },
     data() {
         return {
             items: []

src/plugins/LADTable/components/LadTableSet.vue

@@ -57,10 +57,10 @@
 import LadRow from './LADRow.vue';
 
 export default {
-    inject: ['openmct', 'domainObject'],
     components: {
         LadRow
     },
+    inject: ['openmct', 'domainObject'],
     data() {
         return {
             ladTableObjects: [],

src/plugins/clearData/plugin.js

@@ -37,12 +37,12 @@ define([
         return function install(openmct) {
             if (installIndicator) {
                 let component = new Vue ({
-                    provide: {
-                        openmct
-                    },
                     components: {
                         GlobalClearIndicator: GlobaClearIndicator.default
                     },
+                    provide: {
+                        openmct
+                    },
                     template: '<GlobalClearIndicator></GlobalClearIndicator>'
                 });
 

src/plugins/condition/Condition.js

@@ -75,7 +75,8 @@ export default class Condition extends EventEmitter {
             return;
         }
 
-        if (this.isTelemetryUsed(datum.id)) {
+        // 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)) {
 
             this.criteria.forEach(criterion => {
                 if (this.isAnyOrAllTelemetry(criterion)) {
@@ -93,6 +94,12 @@ 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;
@@ -250,10 +257,17 @@ export default class Condition extends EventEmitter {
     }
 
     getTriggerDescription() {
-        return {
-            conjunction: TRIGGER_CONJUNCTION[this.trigger],
-            prefix: `${TRIGGER_LABEL[this.trigger]}: `
-        };
+        if (this.trigger) {
+            return {
+                conjunction: TRIGGER_CONJUNCTION[this.trigger],
+                prefix: `${TRIGGER_LABEL[this.trigger]}: `
+            };
+        } else {
+            return {
+                conjunction: '',
+                prefix: ''
+            };
+        }
     }
 
     requestLADConditionResult() {

src/plugins/condition/ConditionManager.js

@@ -34,6 +34,9 @@ export default class ConditionManager extends EventEmitter {
         this.composition = this.openmct.composition.get(conditionSetDomainObject);
         this.composition.on('add', this.subscribeToTelemetry, this);
         this.composition.on('remove', this.unsubscribeFromTelemetry, this);
+
+        this.shouldEvaluateNewTelemetry = this.shouldEvaluateNewTelemetry.bind(this);
+
         this.compositionLoad = this.composition.load();
         this.subscriptions = {};
         this.telemetryObjects = {};
@@ -79,6 +82,17 @@ 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() {
@@ -326,6 +340,10 @@ export default class ConditionManager extends EventEmitter {
         return false;
     }
 
+    shouldEvaluateNewTelemetry(currentTimestamp) {
+        return this.openmct.time.bounds().end >= currentTimestamp;
+    }
+
     telemetryReceived(endpoint, datum) {
         if (!this.isTelemetryUsed(endpoint)) {
             return;
@@ -334,16 +352,21 @@ export default class ConditionManager extends EventEmitter {
         const normalizedDatum = this.createNormalizedDatum(datum, endpoint);
         const timeSystemKey = this.openmct.time.timeSystem().key;
         let timestamp = {};
-        timestamp[timeSystemKey] = normalizedDatum[timeSystemKey];
+        const currentTimestamp = normalizedDatum[timeSystemKey];
+        timestamp[timeSystemKey] = currentTimestamp;
+        if (this.shouldEvaluateNewTelemetry(currentTimestamp)) {
+            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,6 +86,7 @@ export default class StyleRuleManager extends EventEmitter {
     updateObjectStyleConfig(styleConfiguration) {
         if (!styleConfiguration || !styleConfiguration.conditionSetIdentifier) {
             this.initialize(styleConfiguration || {});
+            this.applyStaticStyle();
             this.destroy();
         } else {
             let isNewConditionSet = !this.conditionSetIdentifier
@@ -158,7 +159,6 @@ export default class StyleRuleManager extends EventEmitter {
     }
 
     destroy() {
-        this.applyStaticStyle();
         if (this.stopProvidingTelemetry) {
             this.stopProvidingTelemetry();
             delete this.stopProvidingTelemetry;

src/plugins/condition/components/Condition.vue

@@ -195,11 +195,11 @@ import { TRIGGER, TRIGGER_LABEL } from "@/plugins/condition/utils/constants";
 import uuid from 'uuid';
 
 export default {
-    inject: ['openmct'],
     components: {
         Criterion,
         ConditionDescription
     },
+    inject: ['openmct'],
     props: {
         currentConditionId: {
             type: String,

src/plugins/condition/components/ConditionCollection.vue

@@ -81,10 +81,10 @@ import Condition from './Condition.vue';
 import ConditionManager from '../ConditionManager';
 
 export default {
-    inject: ['openmct', 'domainObject'],
     components: {
         Condition
     },
+    inject: ['openmct', 'domainObject'],
     props: {
         isEditing: Boolean,
         testData: {

src/plugins/condition/components/ConditionSet.vue

@@ -58,11 +58,11 @@ import TestData from './TestData.vue';
 import ConditionCollection from './ConditionCollection.vue';
 
 export default {
-    inject: ["openmct", "domainObject"],
     components: {
         TestData,
         ConditionCollection
     },
+    inject: ["openmct", "domainObject"],
     props: {
         isEditing: Boolean
     },

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

@@ -31,7 +31,6 @@
             v-model="expanded"
             class="c-tree__item__view-control"
             :enabled="hasChildren"
-            :propagate="false"
         />
         <div class="c-tree__item__label c-object-label">
             <div
@@ -42,7 +41,7 @@
         </div>
     </div>
     <ul
-        v-if="expanded"
+        v-if="expanded && !isLoading"
         class="c-tree"
     >
         <li
@@ -69,10 +68,10 @@ import viewControl from '@/ui/components/viewControl.vue';
 
 export default {
     name: 'ConditionSetDialogTreeItem',
-    inject: ['openmct'],
     components: {
         viewControl
     },
+    inject: ['openmct'],
     props: {
         node: {
             type: Object,

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

@@ -41,7 +41,7 @@
         ></div>
         <!-- end loading -->
 
-        <div v-if="(allTreeItems.length === 0) || (searchValue && filteredTreeItems.length === 0)"
+        <div v-if="shouldDisplayNoResultsText"
              class="c-tree-and-search__no-results"
         >
             No results found
@@ -63,7 +63,7 @@
         <!-- end main tree -->
 
         <!-- search tree -->
-        <ul v-if="searchValue"
+        <ul v-if="searchValue && !isLoading"
             class="c-tree-and-search__tree c-tree"
         >
             <condition-set-dialog-tree-item
@@ -80,16 +80,17 @@
 </template>
 
 <script>
+import debounce from 'lodash/debounce';
 import search from '@/ui/components/search.vue';
 import ConditionSetDialogTreeItem from './ConditionSetDialogTreeItem.vue';
 
 export default {
-    inject: ['openmct'],
     name: 'ConditionSetSelectorDialog',
     components: {
         search,
         ConditionSetDialogTreeItem
     },
+    inject: ['openmct'],
     data() {
         return {
             expanded: false,
@@ -100,8 +101,20 @@ export default {
             selectedItem: undefined
         };
     },
+    computed: {
+        shouldDisplayNoResultsText() {
+            if (this.isLoading) {
+                return false;
+            }
+
+            return this.allTreeItems.length === 0
+                || (this.searchValue && this.filteredTreeItems.length === 0);
+        }
+    },
+    created() {
+        this.getDebouncedFilteredChildren = debounce(this.getFilteredChildren, 400);
+    },
     mounted() {
-        this.searchService = this.openmct.$injector.get('searchService');
         this.getAllChildren();
     },
     methods: {
@@ -124,37 +137,44 @@ export default {
                 });
         },
         getFilteredChildren() {
-            this.searchService.query(this.searchValue).then(children => {
-                this.filteredTreeItems = children.hits.map(child => {
+            // clear any previous search results
+            this.filteredTreeItems = [];
 
-                    let context = child.object.getCapability('context');
-                    let object = child.object.useCapability('adapter');
-                    let objectPath = [];
-                    let navigateToParent;
+            const promises = this.openmct.objects.search(this.searchValue)
+                .map(promise => promise
+                    .then(results => this.aggregateFilteredChildren(results)));
 
-                    if (context) {
-                        objectPath = context.getPath().slice(1)
-                            .map(oldObject => oldObject.useCapability('adapter'))
-                            .reverse();
-                        navigateToParent = '/browse/' + objectPath.slice(1)
-                            .map((parent) => this.openmct.objects.makeKeyString(parent.identifier))
-                            .join('/');
-                    }
-
-                    return {
-                        id: this.openmct.objects.makeKeyString(object.identifier),
-                        object,
-                        objectPath,
-                        navigateToParent
-                    };
-                });
+            Promise.all(promises).then(() => {
+                this.isLoading = false;
             });
         },
+        async aggregateFilteredChildren(results) {
+            for (const object of results) {
+                const objectPath = await this.openmct.objects.getOriginalPath(object.identifier);
+
+                const navigateToParent = '/browse/'
+                    + objectPath.slice(1)
+                        .map(parent => this.openmct.objects.makeKeyString(parent.identifier))
+                        .join('/');
+
+                const filteredChild = {
+                    id: this.openmct.objects.makeKeyString(object.identifier),
+                    object,
+                    objectPath,
+                    navigateToParent
+                };
+
+                this.filteredTreeItems.push(filteredChild);
+            }
+        },
         searchTree(value) {
             this.searchValue = value;
+            this.isLoading = true;
 
             if (this.searchValue !== '') {
-                this.getFilteredChildren();
+                this.getDebouncedFilteredChildren();
+            } else {
+                this.isLoading = false;
             }
         },
         handleItemSelection(item, node) {

src/plugins/condition/pluginSpec.js

@@ -401,15 +401,15 @@ describe('the plugin', function () {
             let viewContainer = document.createElement('div');
             child.append(viewContainer);
             component = new Vue({
+                el: viewContainer,
+                components: {
+                    StylesView
+                },
                 provide: {
                     openmct: openmct,
                     selection: selection,
                     stylesManager
                 },
-                el: viewContainer,
-                components: {
-                    StylesView
-                },
                 template: '<styles-view/>'
             });
 
@@ -543,7 +543,6 @@ describe('the plugin', function () {
         });
 
         it('should evaluate as stale when telemetry is not received in the allotted time', (done) => {
-
             let conditionMgr = new ConditionManager(conditionSetDomainObject, openmct);
             conditionMgr.on('conditionSetResultUpdated', mockListener);
             conditionMgr.telemetryObjects = {
@@ -565,7 +564,7 @@ describe('the plugin', function () {
         });
 
         it('should not evaluate as stale when telemetry is received in the allotted time', (done) => {
-            const date = Date.now();
+            const date = 1;
             conditionSetDomainObject.configuration.conditionCollection[0].configuration.criteria[0].input = ["0.4"];
             let conditionMgr = new ConditionManager(conditionSetDomainObject, openmct);
             conditionMgr.on('conditionSetResultUpdated', mockListener);

src/plugins/displayLayout/AlphanumericFormatViewProvider.js

@@ -56,14 +56,14 @@ define([
                 return {
                     show: function (element) {
                         component = new Vue({
-                            provide: {
-                                openmct,
-                                objectPath
-                            },
                             el: element,
                             components: {
                                 AlphanumericFormatView: AlphanumericFormatView.default
                             },
+                            provide: {
+                                openmct,
+                                objectPath
+                            },
                             template: '<alphanumeric-format-view ref="alphanumericFormatView"></alphanumeric-format-view>'
                         });
                     },

src/plugins/displayLayout/components/BoxView.vue

@@ -51,11 +51,11 @@ export default {
             height: 5
         };
     },
-    inject: ['openmct'],
     components: {
         LayoutFrame
     },
     mixins: [conditionalStylesMixin],
+    inject: ['openmct'],
     props: {
         item: {
             type: Object,

src/plugins/displayLayout/components/DisplayLayout.vue

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

src/plugins/displayLayout/components/ImageView.vue

@@ -51,11 +51,11 @@ export default {
             url: element.url
         };
     },
-    inject: ['openmct'],
     components: {
         LayoutFrame
     },
     mixins: [conditionalStylesMixin],
+    inject: ['openmct'],
     props: {
         item: {
             type: Object,

src/plugins/displayLayout/components/LineView.vue

@@ -99,8 +99,8 @@ export default {
             stroke: '#717171'
         };
     },
-    inject: ['openmct'],
     mixins: [conditionalStylesMixin],
+    inject: ['openmct'],
     props: {
         item: {
             type: Object,

src/plugins/displayLayout/components/SubobjectView.vue

@@ -80,11 +80,11 @@ export default {
             viewKey
         };
     },
-    inject: ['openmct', 'objectPath'],
     components: {
         ObjectFrame,
         LayoutFrame
     },
+    inject: ['openmct', 'objectPath'],
     props: {
         item: {
             type: Object,
@@ -129,13 +129,22 @@ export default {
         }
     },
     mounted() {
-        this.openmct.objects.get(this.item.identifier)
-            .then(this.setObject);
+        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);
+        }
     },
-    destroyed() {
+    beforeDestroy() {
         if (this.removeSelectable) {
             this.removeSelectable();
         }
+
+        if (this.domainObject.isMutable) {
+            this.openmct.objects.destroyMutable(this.domainObject);
+        }
     },
     methods: {
         setObject(domainObject) {

src/plugins/displayLayout/components/TelemetryView.vue

@@ -98,11 +98,11 @@ export default {
             font: 'default'
         };
     },
-    inject: ['openmct', 'objectPath'],
     components: {
         LayoutFrame
     },
     mixins: [conditionalStylesMixin],
+    inject: ['openmct', 'objectPath'],
     props: {
         item: {
             type: Object,
@@ -212,14 +212,20 @@ export default {
         }
     },
     mounted() {
-        this.openmct.objects.get(this.item.identifier)
-            .then(this.setObject);
+        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.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);
     },
-    destroyed() {
+    beforeDestroy() {
         this.removeSubscription();
         this.removeStatusListener();
 
@@ -228,6 +234,10 @@ export default {
         }
 
         this.openmct.time.off("bounds", this.refreshData);
+
+        if (this.domainObject.isMutable) {
+            this.openmct.objects.destroyMutable(this.domainObject);
+        }
     },
     methods: {
         formattedValueForCopy() {

src/plugins/displayLayout/components/TextView.vue

@@ -59,11 +59,11 @@ export default {
             font: 'default'
         };
     },
-    inject: ['openmct'],
     components: {
         LayoutFrame
     },
     mixins: [conditionalStylesMixin],
+    inject: ['openmct'],
     props: {
         item: {
             type: Object,

src/plugins/duplicate/pluginSpec.js

@@ -57,6 +57,7 @@ describe("The Duplicate Action plugin", () => {
             overwrite: {
                 folder: {
                     name: "Parent Folder",
+                    type: "folder",
                     composition: [childObject.identifier]
                 }
             }
@@ -104,6 +105,7 @@ 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/filters/FiltersInspectorViewProvider.js

@@ -47,13 +47,13 @@ define([
                 return {
                     show: function (element) {
                         component = new Vue({
-                            provide: {
-                                openmct
-                            },
                             el: element,
                             components: {
                                 FiltersView: FiltersView.default
                             },
+                            provide: {
+                                openmct
+                            },
                             template: '<filters-view></filters-view>'
                         });
                     },

src/plugins/filters/components/FilterObject.vue

@@ -65,11 +65,11 @@ import ToggleSwitch from '../../../ui/components/ToggleSwitch.vue';
 import isEmpty from 'lodash/isEmpty';
 
 export default {
-    inject: ['openmct'],
     components: {
         FilterField,
         ToggleSwitch
     },
+    inject: ['openmct'],
     props: {
         filterObject: {
             type: Object,

src/plugins/filters/components/GlobalFilters.vue

@@ -41,10 +41,10 @@
 import FilterField from './FilterField.vue';
 
 export default {
-    inject: ['openmct'],
     components: {
         FilterField
     },
+    inject: ['openmct'],
     props: {
         globalMetadata: {
             type: Object,

src/plugins/flexibleLayout/components/container.vue

@@ -87,12 +87,12 @@ import DropHint from './dropHint.vue';
 const MIN_FRAME_SIZE = 5;
 
 export default {
-    inject: ['openmct'],
     components: {
         FrameComponent,
         ResizeHandle,
         DropHint
     },
+    inject: ['openmct'],
     props: {
         container: {
             type: Object,

src/plugins/flexibleLayout/components/flexibleLayout.vue

@@ -28,7 +28,7 @@
     ></div>
 
     <div
-        v-if="areAllContainersEmpty()"
+        v-if="allContainersAreEmpty"
         class="c-fl__empty"
     >
         <span class="c-fl__empty-message">This Flexible Layout is currently empty</span>
@@ -94,7 +94,6 @@ import Container from '../utils/container';
 import Frame from '../utils/frame';
 import ResizeHandle from './resizeHandle.vue';
 import DropHint from './dropHint.vue';
-import RemoveAction from '../../remove/RemoveAction.js';
 
 const MIN_CONTAINER_SIZE = 5;
 
@@ -140,19 +139,20 @@ function sizeToFill(items) {
 }
 
 export default {
-    inject: ['openmct', 'objectPath', 'layoutObject'],
     components: {
         ContainerComponent,
         ResizeHandle,
         DropHint
     },
+    inject: ['openmct', 'objectPath', 'layoutObject'],
     props: {
         isEditing: Boolean
     },
     data() {
         return {
             domainObject: this.layoutObject,
-            newFrameLocation: []
+            newFrameLocation: [],
+            identifierMap: {}
         };
     },
     computed: {
@@ -168,26 +168,30 @@ export default {
         },
         rowsLayout() {
             return this.domainObject.configuration.rowsLayout;
+        },
+        allContainersAreEmpty() {
+            return this.containers.every(container => container.frames.length === 0);
         }
     },
     mounted() {
+        this.buildIdentifierMap();
         this.composition = this.openmct.composition.get(this.domainObject);
         this.composition.on('remove', this.removeChildObject);
         this.composition.on('add', this.addFrame);
-
-        this.RemoveAction = new RemoveAction(this.openmct);
-
-        this.unobserve = this.openmct.objects.observe(this.domainObject, '*', this.updateDomainObject);
+        this.composition.load();
     },
     beforeDestroy() {
         this.composition.off('remove', this.removeChildObject);
         this.composition.off('add', this.addFrame);
-
-        this.unobserve();
     },
     methods: {
-        areAllContainersEmpty() {
-            return !this.containers.filter(container => container.frames.length).length;
+        buildIdentifierMap() {
+            this.containers.forEach(container => {
+                container.frames.forEach(frame => {
+                    let keystring = this.openmct.objects.makeKeyString(frame.domainObjectIdentifier);
+                    this.identifierMap[keystring] = true;
+                });
+            });
         },
         addContainer() {
             let container = new Container();
@@ -236,16 +240,21 @@ export default {
             this.newFrameLocation = [containerIndex, insertFrameIndex];
         },
         addFrame(domainObject) {
-            let containerIndex = this.newFrameLocation.length ? this.newFrameLocation[0] : 0;
-            let container = this.containers[containerIndex];
-            let frameIndex = this.newFrameLocation.length ? this.newFrameLocation[1] : container.frames.length;
-            let frame = new Frame(domainObject.identifier);
+            let keystring = this.openmct.objects.makeKeyString(domainObject.identifier);
 
-            container.frames.splice(frameIndex + 1, 0, frame);
-            sizeItems(container.frames, frame);
+            if (!this.identifierMap[keystring]) {
+                let containerIndex = this.newFrameLocation.length ? this.newFrameLocation[0] : 0;
+                let container = this.containers[containerIndex];
+                let frameIndex = this.newFrameLocation.length ? this.newFrameLocation[1] : container.frames.length;
+                let frame = new Frame(domainObject.identifier);
 
-            this.newFrameLocation = [];
-            this.persist(containerIndex);
+                container.frames.splice(frameIndex + 1, 0, frame);
+                sizeItems(container.frames, frame);
+
+                this.newFrameLocation = [];
+                this.persist(containerIndex);
+                this.identifierMap[keystring] = true;
+            }
         },
         deleteFrame(frameId) {
             let container = this.containers
@@ -254,16 +263,20 @@ export default {
                 .frames
                 .filter((f => f.id === frameId))[0];
 
-            this.removeFromComposition(frame.domainObjectIdentifier)
-                .then(() => {
-                    sizeToFill(container.frames);
-                    this.setSelectionToParent();
-                });
+            this.removeFromComposition(frame.domainObjectIdentifier);
+
+            this.$nextTick().then(() => {
+                sizeToFill(container.frames);
+                this.setSelectionToParent();
+            });
         },
         removeFromComposition(identifier) {
-            return this.openmct.objects.get(identifier).then((childDomainObject) => {
-                this.RemoveAction.removeFromComposition(this.domainObject, childDomainObject);
-            });
+            let keystring = this.openmct.objects.makeKeyString(identifier);
+
+            this.identifierMap[keystring] = undefined;
+            delete this.identifierMap[keystring];
+
+            this.composition.remove({identifier});
         },
         setSelectionToParent() {
             this.$el.click();

src/plugins/flexibleLayout/components/frame.vue

@@ -58,10 +58,10 @@
 import ObjectFrame from '../../../ui/components/ObjectFrame.vue';
 
 export default {
-    inject: ['openmct'],
     components: {
         ObjectFrame
     },
+    inject: ['openmct'],
     props: {
         frame: {
             type: Object,

src/plugins/flexibleLayout/flexibleLayoutViewProvider.js

@@ -44,15 +44,15 @@ define([
                 return {
                     show: function (element, isEditing) {
                         component = new Vue({
+                            el: element,
+                            components: {
+                                FlexibleLayoutComponent: FlexibleLayoutComponent.default
+                            },
                             provide: {
                                 openmct,
                                 objectPath,
                                 layoutObject: domainObject
                             },
-                            el: element,
-                            components: {
-                                FlexibleLayoutComponent: FlexibleLayoutComponent.default
-                            },
                             data() {
                                 return {
                                     isEditing: isEditing

src/plugins/folderView/FolderGridView.js

@@ -22,18 +22,22 @@
 
 define([
     './components/GridView.vue',
+    './constants.js',
     'vue'
 ], function (
     GridViewComponent,
+    constants,
     Vue
 ) {
     function FolderGridView(openmct) {
+        const ALLOWED_FOLDER_TYPES = constants.ALLOWED_FOLDER_TYPES;
+
         return {
             key: 'grid',
             name: 'Grid View',
             cssClass: 'icon-thumbs-strip',
             canView: function (domainObject) {
-                return domainObject.type === 'folder';
+                return ALLOWED_FOLDER_TYPES.includes(domainObject.type);
             },
             view: function (domainObject) {
                 let component;

src/plugins/folderView/FolderListView.js

@@ -22,20 +22,24 @@
 
 define([
     './components/ListView.vue',
+    './constants.js',
     'vue',
     'moment'
 ], function (
     ListViewComponent,
+    constants,
     Vue,
     Moment
 ) {
     function FolderListView(openmct) {
+        const ALLOWED_FOLDER_TYPES = constants.ALLOWED_FOLDER_TYPES;
+
         return {
             key: 'list-view',
             name: 'List View',
             cssClass: 'icon-list-view',
             canView: function (domainObject) {
-                return domainObject.type === 'folder';
+                return ALLOWED_FOLDER_TYPES.includes(domainObject.type);
             },
             view: function (domainObject) {
                 let component;

src/plugins/folderView/components/ListItem.vue

@@ -1,7 +1,9 @@
 <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/folderView/constants.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, United States Government
+ * Open MCT, Copyright (c) 2014-2021, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *
@@ -20,13 +20,4 @@
  * at runtime from the About dialog for additional information.
  *****************************************************************************/
 
-define([
-    "EventEmitter"
-], function (
-    EventEmitter
-) {
-    /**
-     * Provides a singleton event bus for sharing between objects.
-     */
-    return new EventEmitter();
-});
+export const ALLOWED_FOLDER_TYPES = ['folder', 'noneditable.folder'];

src/plugins/goToOriginalAction/pluginSpec.js

@@ -0,0 +1,73 @@
+/*****************************************************************************
+ * 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 plugin", () => {
+    let openmct;
+    let goToFolderAction;
+    let mockObjectPath;
+
+    beforeEach((done) => {
+        openmct = createOpenMct();
+
+        openmct.on('start', done);
+        openmct.startHeadless();
+
+        goToFolderAction = openmct.actions._allActions.goToOriginal;
+    });
+
+    afterEach(() => {
+        return resetApplicationState(openmct);
+    });
+
+    it('installs the go to folder action', () => {
+        expect(goToFolderAction).toBeDefined();
+    });
+
+    describe('when invoked', () => {
+
+        beforeEach(() => {
+            mockObjectPath = [{
+                name: 'mock folder',
+                type: 'folder',
+                identifier: {
+                    key: 'mock-folder',
+                    namespace: ''
+                }
+            }];
+            spyOn(openmct.objects, 'get').and.returnValue(Promise.resolve({
+                identifier: {
+                    namespace: '',
+                    key: 'test'
+                }
+            }));
+            goToFolderAction.invoke(mockObjectPath);
+        });
+
+        it('goes to the original location', () => {
+            expect(window.location.href).toContain('context.html#/browse/?tc.mode=fixed&tc.startBound=0&tc.endBound=1&tc.timeSystem=utc');
+        });
+    });
+});

src/plugins/interceptors/pluginSpec.js

@@ -0,0 +1,99 @@
+/*****************************************************************************
+ * 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";
+import InterceptorPlugin from "./plugin";
+
+describe('the plugin', function () {
+    let element;
+    let child;
+    let openmct;
+    const TEST_NAMESPACE = 'test';
+
+    beforeEach((done) => {
+        const appHolder = document.createElement('div');
+        appHolder.style.width = '640px';
+        appHolder.style.height = '480px';
+
+        openmct = createOpenMct();
+        openmct.install(new InterceptorPlugin(openmct));
+
+        element = document.createElement('div');
+        element.style.width = '640px';
+        element.style.height = '480px';
+        child = document.createElement('div');
+        child.style.width = '640px';
+        child.style.height = '480px';
+        element.appendChild(child);
+
+        openmct.on('start', done);
+        openmct.startHeadless(appHolder);
+    });
+
+    afterEach(() => {
+        return resetApplicationState(openmct);
+    });
+
+    describe('the missingObjectInterceptor', () => {
+        let mockProvider;
+        beforeEach(() => {
+            mockProvider = jasmine.createSpyObj("mock provider", [
+                "get"
+            ]);
+            mockProvider.get.and.returnValue(Promise.resolve(undefined));
+            openmct.objects.addProvider(TEST_NAMESPACE, mockProvider);
+        });
+
+        it('returns missing objects', (done) => {
+            const identifier = {
+                namespace: TEST_NAMESPACE,
+                key: 'hello'
+            };
+            openmct.objects.get(identifier).then((testObject) => {
+                expect(testObject).toEqual({
+                    identifier,
+                    type: 'unknown',
+                    name: 'Missing: test:hello'
+                });
+                done();
+            });
+        });
+
+        it('returns the My items object if not found', (done) => {
+            const identifier = {
+                namespace: TEST_NAMESPACE,
+                key: 'mine'
+            };
+            openmct.objects.get(identifier).then((testObject) => {
+                expect(testObject).toEqual({
+                    identifier,
+                    "name": "My Items",
+                    "type": "folder",
+                    "composition": [],
+                    "location": "ROOT"
+                });
+                done();
+            });
+        });
+
+    });
+});

src/plugins/nonEditableFolder/plugin.js

@@ -0,0 +1,33 @@
+/*****************************************************************************
+ * 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 () {
+    return function (openmct) {
+        openmct.types.addType("noneditable.folder", {
+            name: "Non-Editable Folder",
+            key: "noneditable.folder",
+            description: "Create folders to organize other objects or links to objects without the ability to edit it's properties.",
+            cssClass: "icon-folder",
+            creatable: false
+        });
+    };
+}

src/plugins/nonEditableFolder/pluginSpec.js

@@ -0,0 +1,50 @@
+/*****************************************************************************
+ * 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 plugin", () => {
+    const NON_EDITABLE_FOLDER_KEY = 'noneditable.folder';
+    let openmct;
+
+    beforeEach((done) => {
+        openmct = createOpenMct();
+        openmct.install(openmct.plugins.NonEditableFolder());
+
+        openmct.on('start', done);
+        openmct.startHeadless();
+    });
+
+    afterEach(() => {
+        return resetApplicationState(openmct);
+    });
+
+    it('adds the new non-editable folder type', () => {
+        const type = openmct.types.get(NON_EDITABLE_FOLDER_KEY);
+
+        expect(type).toBeDefined();
+        expect(type.definition.creatable).toBeFalse();
+    });
+
+});

src/plugins/notebook/components/Notebook.vue

@@ -97,7 +97,8 @@
                                :selected-page="getSelectedPage()"
                                :selected-section="getSelectedSection()"
                                :read-only="false"
-                               @updateEntries="updateEntries"
+                               @deleteEntry="deleteEntry"
+                               @updateEntry="updateEntry"
                 />
             </div>
         </div>
@@ -111,19 +112,20 @@ import Search from '@/ui/components/search.vue';
 import SearchResults from './SearchResults.vue';
 import Sidebar from './Sidebar.vue';
 import { clearDefaultNotebook, getDefaultNotebook, setDefaultNotebook, setDefaultNotebookSection, setDefaultNotebookPage } from '../utils/notebook-storage';
-import { addNotebookEntry, createNewEmbed, getNotebookEntries, mutateObject } from '../utils/notebook-entries';
+import { addNotebookEntry, createNewEmbed, getEntryPosById, getNotebookEntries, mutateObject } from '../utils/notebook-entries';
 import objectUtils from 'objectUtils';
 
 import { throttle } from 'lodash';
+import objectLink from '../../../ui/mixins/object-link';
 
 export default {
-    inject: ['openmct', 'domainObject', 'snapshotContainer'],
     components: {
         NotebookEntry,
         Search,
         SearchResults,
         Sidebar
     },
+    inject: ['openmct', 'domainObject', 'snapshotContainer'],
     data() {
         return {
             defaultPageId: getDefaultNotebook() ? getDefaultNotebook().page.id : '',
@@ -182,7 +184,9 @@ export default {
     mounted() {
         this.unlisten = this.openmct.objects.observe(this.internalDomainObject, '*', this.updateInternalDomainObject);
         this.formatSidebar();
+
         window.addEventListener('orientationchange', this.formatSidebar);
+        window.addEventListener("hashchange", this.navigateToSectionPage, false);
 
         this.navigateToSectionPage();
     },
@@ -190,6 +194,9 @@ export default {
         if (this.unlisten) {
             this.unlisten();
         }
+
+        window.removeEventListener('orientationchange', this.formatSidebar);
+        window.removeEventListener("hashchange", this.navigateToSectionPage);
     },
     updated: function () {
         this.$nextTick(() => {
@@ -226,18 +233,49 @@ export default {
         createNotebookStorageObject() {
             const notebookMeta = {
                 name: this.internalDomainObject.name,
-                identifier: this.internalDomainObject.identifier
+                identifier: this.internalDomainObject.identifier,
+                link: this.getLinktoNotebook()
             };
             const page = this.getSelectedPage();
             const section = this.getSelectedSection();
 
             return {
-                domainObject: this.internalDomainObject,
                 notebookMeta,
-                section,
-                page
+                page,
+                section
             };
         },
+        deleteEntry(entryId) {
+            const self = this;
+            const entryPos = getEntryPosById(entryId, this.internalDomainObject, this.selectedSection, this.selectedPage);
+            if (entryPos === -1) {
+                this.openmct.notifications.alert('Warning: unable to delete entry');
+                console.error(`unable to delete entry ${entryId} from section ${this.selectedSection}, page ${this.selectedPage}`);
+
+                return;
+            }
+
+            const dialog = this.openmct.overlays.dialog({
+                iconClass: 'alert',
+                message: 'This action will permanently delete this entry. Do you wish to continue?',
+                buttons: [
+                    {
+                        label: "Ok",
+                        emphasis: true,
+                        callback: () => {
+                            const entries = getNotebookEntries(self.internalDomainObject, self.selectedSection, self.selectedPage);
+                            entries.splice(entryPos, 1);
+                            self.updateEntries(entries);
+                            dialog.dismiss();
+                        }
+                    },
+                    {
+                        label: "Cancel",
+                        callback: () => dialog.dismiss()
+                    }
+                ]
+            });
+        },
         dragOver(event) {
             event.preventDefault();
             event.dataTransfer.dropEffect = "copy";
@@ -311,6 +349,20 @@ export default {
 
             return this.openmct.objects.get(oldNotebookStorage.notebookMeta.identifier);
         },
+        getLinktoNotebook() {
+            const objectPath = this.openmct.router.path;
+            const link = objectLink.computed.objectLink.call({
+                objectPath,
+                openmct: this.openmct
+            });
+
+            const selectedSection = this.selectedSection;
+            const selectedPage = this.selectedPage;
+            const sectionId = selectedSection ? selectedSection.id : '';
+            const pageId = selectedPage ? selectedPage.id : '';
+
+            return `${link}?sectionId=${sectionId}&pageId=${pageId}`;
+        },
         getPage(section, id) {
             return section.pages.find(p => p.id === id);
         },
@@ -395,6 +447,12 @@ export default {
                 return s;
             });
 
+            const selectedSectionId = this.selectedSection && this.selectedSection.id;
+            const selectedPageId = this.selectedPage && this.selectedPage.id;
+            if (selectedPageId === pageId && selectedSectionId === sectionId) {
+                return;
+            }
+
             this.sectionsChanged({ sections });
         },
         newEntry(embed = null) {
@@ -442,10 +500,10 @@ export default {
         async updateDefaultNotebook(notebookStorage) {
             const defaultNotebookObject = await this.getDefaultNotebookObject();
             if (!defaultNotebookObject) {
-                setDefaultNotebook(this.openmct, notebookStorage);
+                setDefaultNotebook(this.openmct, notebookStorage, this.internalDomainObject);
             } else if (objectUtils.makeKeyString(defaultNotebookObject.identifier) !== objectUtils.makeKeyString(notebookStorage.notebookMeta.identifier)) {
                 this.removeDefaultClass(defaultNotebookObject);
-                setDefaultNotebook(this.openmct, notebookStorage);
+                setDefaultNotebook(this.openmct, notebookStorage, this.internalDomainObject);
             }
 
             if (this.defaultSectionId && this.defaultSectionId.length === 0 || this.defaultSectionId !== notebookStorage.section.id) {
@@ -514,6 +572,13 @@ export default {
 
             setDefaultNotebookSection(section);
         },
+        updateEntry(entry) {
+            const entries = getNotebookEntries(this.internalDomainObject, this.selectedSection, this.selectedPage);
+            const entryPos = getEntryPosById(entry.id, this.internalDomainObject, this.selectedSection, this.selectedPage);
+            entries[entryPos] = entry;
+
+            this.updateEntries(entries);
+        },
         updateEntries(entries) {
             const configuration = this.internalDomainObject.configuration;
             const notebookEntries = configuration.entries || {};

src/plugins/notebook/components/NotebookEmbed.vue

@@ -33,10 +33,10 @@ import SnapshotTemplate from './snapshot-template.html';
 import Vue from 'vue';
 
 export default {
-    inject: ['openmct'],
     components: {
         PopupMenu
     },
+    inject: ['openmct'],
     props: {
         embed: {
             type: Object,

src/plugins/notebook/components/NotebookEntry.vue

@@ -12,11 +12,15 @@
         <div class="c-ne__content">
             <div :id="entry.id"
                  class="c-ne__text"
-                 :class="{'c-ne__input' : !readOnly }"
+                 tabindex="0"
+                 :class="{ 'c-ne__input' : !readOnly }"
                  :contenteditable="!readOnly"
-                 @blur="updateEntryValue($event, entry.id)"
-                 @focus="updateCurrentEntryValue($event, entry.id)"
-            >{{ entry.text }}</div>
+                 @blur="updateEntryValue($event)"
+                 @keydown.enter.exact.prevent
+                 @keyup.enter.exact.prevent="forceBlur($event)"
+                 v-text="entry.text"
+            >
+            </div>
             <div class="c-snapshots c-ne__embeds">
                 <NotebookEmbed v-for="embed in entry.embeds"
                                :key="embed.id"
@@ -33,6 +37,7 @@
     >
         <button class="c-icon-button c-icon-button--major icon-trash"
                 title="Delete this entry"
+                tabindex="-1"
                 @click="deleteEntry"
         >
         </button>
@@ -57,14 +62,14 @@
 
 <script>
 import NotebookEmbed from './NotebookEmbed.vue';
-import { createNewEmbed, getEntryPosById, getNotebookEntries } from '../utils/notebook-entries';
+import { createNewEmbed } from '../utils/notebook-entries';
 import Moment from 'moment';
 
 export default {
-    inject: ['openmct', 'snapshotContainer'],
     components: {
         NotebookEmbed
     },
+    inject: ['openmct', 'snapshotContainer'],
     props: {
         domainObject: {
             type: Object,
@@ -103,11 +108,6 @@ export default {
             }
         }
     },
-    data() {
-        return {
-            currentEntryValue: ''
-        };
-    },
     computed: {
         createdOnDate() {
             return this.formatTime(this.entry.createdOn, 'YYYY-MM-DD');
@@ -117,10 +117,20 @@ export default {
         }
     },
     mounted() {
-        this.updateEntries = this.updateEntries.bind(this);
         this.dropOnEntry = this.dropOnEntry.bind(this);
     },
     methods: {
+        addNewEmbed(objectPath) {
+            const bounds = this.openmct.time.bounds();
+            const snapshotMeta = {
+                bounds,
+                link: null,
+                objectPath,
+                openmct: this.openmct
+            };
+            const newEmbed = createNewEmbed(snapshotMeta);
+            this.entry.embeds.push(newEmbed);
+        },
         cancelEditMode(event) {
             const isEditing = this.openmct.editor.isEditing();
             if (isEditing) {
@@ -132,63 +142,23 @@ export default {
             event.dataTransfer.dropEffect = "copy";
         },
         deleteEntry() {
-            const self = this;
-            const entryPosById = self.entryPosById(self.entry.id);
-            if (entryPosById === -1) {
-                return;
-            }
-
-            const dialog = this.openmct.overlays.dialog({
-                iconClass: 'alert',
-                message: 'This action will permanently delete this entry. Do you wish to continue?',
-                buttons: [
-                    {
-                        label: "Ok",
-                        emphasis: true,
-                        callback: () => {
-                            const entries = getNotebookEntries(self.domainObject, self.selectedSection, self.selectedPage);
-                            entries.splice(entryPosById, 1);
-                            self.updateEntries(entries);
-                            dialog.dismiss();
-                        }
-                    },
-                    {
-                        label: "Cancel",
-                        callback: () => {
-                            dialog.dismiss();
-                        }
-                    }
-                ]
-            });
+            this.$emit('deleteEntry', this.entry.id);
         },
         dropOnEntry($event) {
             event.stopImmediatePropagation();
 
             const snapshotId = $event.dataTransfer.getData('openmct/snapshot/id');
             if (snapshotId.length) {
-                this.moveSnapshot(snapshotId);
-
-                return;
+                const snapshot = this.snapshotContainer.getSnapshot(snapshotId);
+                this.snapshotContainer.removeSnapshot(snapshotId);
+                this.entry.embeds.push(snapshot);
+            } else {
+                const data = $event.dataTransfer.getData('openmct/domain-object-path');
+                const objectPath = JSON.parse(data);
+                this.addNewEmbed(objectPath);
             }
 
-            const data = $event.dataTransfer.getData('openmct/domain-object-path');
-            const objectPath = JSON.parse(data);
-            const entryPos = this.entryPosById(this.entry.id);
-            const bounds = this.openmct.time.bounds();
-            const snapshotMeta = {
-                bounds,
-                link: null,
-                objectPath,
-                openmct: this.openmct
-            };
-            const newEmbed = createNewEmbed(snapshotMeta);
-            const entries = getNotebookEntries(this.domainObject, this.selectedSection, this.selectedPage);
-            const currentEntryEmbeds = entries[entryPos].embeds;
-            currentEntryEmbeds.push(newEmbed);
-            this.updateEntries(entries);
-        },
-        entryPosById(entryId) {
-            return getEntryPosById(entryId, this.domainObject, this.selectedSection, this.selectedPage);
+            this.$emit('updateEntry', this.entry);
         },
         findPositionInArray(array, id) {
             let position = -1;
@@ -203,15 +173,12 @@ export default {
 
             return position;
         },
+        forceBlur(event) {
+            event.target.blur();
+        },
         formatTime(unixTime, timeFormat) {
             return Moment.utc(unixTime).format(timeFormat);
         },
-        moveSnapshot(snapshotId) {
-            const snapshot = this.snapshotContainer.getSnapshot(snapshotId);
-            this.entry.embeds.push(snapshot);
-            this.updateEntry(this.entry);
-            this.snapshotContainer.removeSnapshot(snapshotId);
-        },
         navigateToPage() {
             this.$emit('changeSectionPage', {
                 sectionId: this.result.section.id,
@@ -227,15 +194,8 @@ export default {
         removeEmbed(id) {
             const embedPosition = this.findPositionInArray(this.entry.embeds, id);
             this.entry.embeds.splice(embedPosition, 1);
-            this.updateEntry(this.entry);
-        },
-        updateCurrentEntryValue($event) {
-            if (this.readOnly) {
-                return;
-            }
 
-            const target = $event.target;
-            this.currentEntryValue = target ? target.textContent : '';
+            this.$emit('updateEntry', this.entry);
         },
         updateEmbed(newEmbed) {
             this.entry.embeds.some(e => {
@@ -247,44 +207,14 @@ export default {
                 return found;
             });
 
-            this.updateEntry(this.entry);
+            this.$emit('updateEntry', this.entry);
         },
-        updateEntry(newEntry) {
-            const entries = getNotebookEntries(this.domainObject, this.selectedSection, this.selectedPage);
-            entries.some(entry => {
-                const found = (entry.id === newEntry.id);
-                if (found) {
-                    entry = newEntry;
-                }
-
-                return found;
-            });
-
-            this.updateEntries(entries);
-        },
-        updateEntryValue($event, entryId) {
-            if (!this.domainObject || !this.selectedSection || !this.selectedPage) {
-                return;
+        updateEntryValue($event) {
+            const value = $event.target.innerText;
+            if (value !== this.entry.text && value.match(/\S/)) {
+                this.entry.text = value;
+                this.$emit('updateEntry', this.entry);
             }
-
-            const target = $event.target;
-            if (!target) {
-                return;
-            }
-
-            const entryPos = this.entryPosById(entryId);
-            const value = target.textContent.trim();
-            if (this.currentEntryValue !== value) {
-                target.textContent = value;
-
-                const entries = getNotebookEntries(this.domainObject, this.selectedSection, this.selectedPage);
-                entries[entryPos].text = value;
-
-                this.updateEntries(entries);
-            }
-        },
-        updateEntries(entries) {
-            this.$emit('updateEntries', entries);
         }
     }
 };

src/plugins/notebook/components/NotebookMenuSwitcher.vue

@@ -44,38 +44,46 @@ export default {
     },
     data() {
         return {
-            notebookSnapshot: null,
+            notebookSnapshot: undefined,
             notebookTypes: []
         };
     },
     mounted() {
         validateNotebookStorageObject();
+        this.getDefaultNotebookObject();
 
         this.notebookSnapshot = new Snapshot(this.openmct);
         this.setDefaultNotebookStatus();
     },
     methods: {
-        showMenu(event) {
-            const notebookTypes = [];
+        async getDefaultNotebookObject() {
             const defaultNotebook = getDefaultNotebook();
+            const defaultNotebookObject = defaultNotebook && await this.openmct.objects.get(defaultNotebook.notebookMeta.identifier);
+
+            return defaultNotebookObject;
+        },
+        async showMenu(event) {
+            const notebookTypes = [];
             const elementBoundingClientRect = this.$el.getBoundingClientRect();
             const x = elementBoundingClientRect.x;
             const y = elementBoundingClientRect.y + elementBoundingClientRect.height;
 
-            if (defaultNotebook) {
-                const domainObject = defaultNotebook.domainObject;
+            const defaultNotebookObject = await this.getDefaultNotebookObject();
+            if (defaultNotebookObject) {
+                const name = defaultNotebookObject.name;
 
-                if (domainObject.location) {
-                    const defaultPath = `${domainObject.name} - ${defaultNotebook.section.name} - ${defaultNotebook.page.name}`;
+                const defaultNotebook = getDefaultNotebook();
+                const sectionName = defaultNotebook.section.name;
+                const pageName = defaultNotebook.page.name;
+                const defaultPath = `${name} - ${sectionName} - ${pageName}`;
 
-                    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/components/NotebookSnapshotContainer.vue

@@ -56,11 +56,11 @@ import { NOTEBOOK_SNAPSHOT_MAX_COUNT } from '../snapshot-container';
 import { EVENT_SNAPSHOTS_UPDATED } from '../notebook-constants';
 
 export default {
-    inject: ['openmct', 'snapshotContainer'],
     components: {
         NotebookEmbed,
         PopupMenu
     },
+    inject: ['openmct', 'snapshotContainer'],
     props: {
         toggleSnapshot: {
             type: Function,

src/plugins/notebook/components/NotebookSnapshotIndicator.vue

@@ -69,14 +69,14 @@ export default {
             const divElement = document.querySelector('.l-shell__drawer div');
 
             this.component = new Vue({
-                provide: {
-                    openmct,
-                    snapshotContainer
-                },
                 el: divElement,
                 components: {
                     SnapshotContainerComponent
                 },
+                provide: {
+                    openmct,
+                    snapshotContainer
+                },
                 data() {
                     return {
                         toggleSnapshot

src/plugins/notebook/components/PageCollection.vue

@@ -22,10 +22,10 @@ import { getDefaultNotebook } from '../utils/notebook-storage';
 import Page from './PageComponent.vue';
 
 export default {
-    inject: ['openmct'],
     components: {
         Page
     },
+    inject: ['openmct'],
     props: {
         defaultPageId: {
             type: String,

src/plugins/notebook/components/PageComponent.vue

@@ -18,10 +18,10 @@ import PopupMenu from './PopupMenu.vue';
 import RemoveDialog from '../utils/removeDialog';
 
 export default {
-    inject: ['openmct'],
     components: {
         PopupMenu
     },
+    inject: ['openmct'],
     props: {
         defaultPageId: {
             type: String,

src/plugins/notebook/components/SearchResults.vue

@@ -21,10 +21,10 @@
 import NotebookEntry from './NotebookEntry.vue';
 
 export default {
-    inject: ['openmct', 'snapshotContainer'],
     components: {
         NotebookEntry
     },
+    inject: ['openmct', 'snapshotContainer'],
     props: {
         domainObject: {
             type: Object,

src/plugins/notebook/components/SectionCollection.vue

@@ -22,10 +22,10 @@ import { getDefaultNotebook } from '../utils/notebook-storage';
 import sectionComponent from './SectionComponent.vue';
 
 export default {
-    inject: ['openmct'],
     components: {
         sectionComponent
     },
+    inject: ['openmct'],
     props: {
         defaultSectionId: {
             type: String,

src/plugins/notebook/components/SectionComponent.vue

@@ -21,10 +21,10 @@ import PopupMenu from './PopupMenu.vue';
 import RemoveDialog from '../utils/removeDialog';
 
 export default {
-    inject: ['openmct'],
     components: {
         PopupMenu
     },
+    inject: ['openmct'],
     props: {
         defaultSectionId: {
             type: String,

src/plugins/notebook/components/Sidebar.vue

@@ -61,11 +61,11 @@ import PageCollection from './PageCollection.vue';
 import uuid from 'uuid';
 
 export default {
-    inject: ['openmct'],
     components: {
         SectionCollection,
         PageCollection
     },
+    inject: ['openmct'],
     props: {
         defaultPageId: {
             type: String,

src/plugins/notebook/plugin.js

@@ -88,13 +88,13 @@ export default function NotebookPlugin() {
 
         const snapshotContainer = new SnapshotContainer(openmct);
         const notebookSnapshotIndicator = new Vue ({
+            components: {
+                NotebookSnapshotIndicator
+            },
             provide: {
                 openmct,
                 snapshotContainer
             },
-            components: {
-                NotebookSnapshotIndicator
-            },
             template: '<NotebookSnapshotIndicator></NotebookSnapshotIndicator>'
         });
         const indicator = {

src/plugins/notebook/snapshot.js

@@ -1,5 +1,5 @@
 import { addNotebookEntry, createNewEmbed } from './utils/notebook-entries';
-import { getDefaultNotebook } from './utils/notebook-storage';
+import { getDefaultNotebook, getDefaultNotebookLink, setDefaultNotebook } from './utils/notebook-storage';
 import { NOTEBOOK_DEFAULT } from '@/plugins/notebook/notebook-constants';
 import SnapshotContainer from './snapshot-container';
 
@@ -45,12 +45,21 @@ export default class Snapshot {
     _saveToDefaultNoteBook(embed) {
         const notebookStorage = getDefaultNotebook();
         this.openmct.objects.get(notebookStorage.notebookMeta.identifier)
-            .then(domainObject => {
+            .then(async (domainObject) => {
                 addNotebookEntry(this.openmct, domainObject, notebookStorage, embed);
 
+                let link = notebookStorage.notebookMeta.link;
+
+                // Backwards compatibility fix (old notebook model without link)
+                if (!link) {
+                    link = await getDefaultNotebookLink(this.openmct, domainObject);
+                    notebookStorage.notebookMeta.link = link;
+                    setDefaultNotebook(this.openmct, notebookStorage);
+                }
+
                 const defaultPath = `${domainObject.name} - ${notebookStorage.section.name} - ${notebookStorage.page.name}`;
                 const msg = `Saved to Notebook ${defaultPath}`;
-                this._showNotification(msg);
+                this._showNotification(msg, link);
             });
     }
 
@@ -58,16 +67,29 @@ export default class Snapshot {
      * @private
      */
     _saveToNotebookSnapshots(embed) {
-        const saved = this.snapshotContainer.addSnapshot(embed);
-        if (!saved) {
-            return;
+        this.snapshotContainer.addSnapshot(embed);
+    }
+
+    _showNotification(msg, url) {
+        const options = {
+            autoDismissTimeout: 30000,
+            link: {
+                cssClass: '',
+                text: 'click to view',
+                onClick: this._navigateToNotebook(url)
+            }
+        };
+
+        this.openmct.notifications.info(msg, options);
+    }
+
+    _navigateToNotebook(url = null) {
+        if (!url) {
+            return () => {};
         }
 
-        const msg = 'Saved to Notebook Snapshots - click to view.';
-        this._showNotification(msg);
-    }
-
-    _showNotification(msg) {
-        this.openmct.notifications.info(msg);
+        return () => {
+            window.location.href = window.location.origin + url;
+        };
     }
 }

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

@@ -23,13 +23,6 @@ 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: {
@@ -116,10 +109,30 @@ const selectedPage = {
 };
 
 let openmct;
+let mockIdentifierService;
 
 describe('Notebook Entries:', () => {
     beforeEach(done => {
         openmct = createOpenMct();
+        openmct.$injector = jasmine.createSpyObj('$injector', ['get']);
+        mockIdentifierService = jasmine.createSpyObj(
+            'identifierService',
+            ['parse']
+        );
+        mockIdentifierService.parse.and.returnValue({
+            getSpace: () => {
+                return '';
+            }
+        });
+
+        openmct.$injector.get.and.returnValue(mockIdentifierService);
+        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,13 +1,12 @@
+import objectUtils from 'objectUtils';
+
 const NOTEBOOK_LOCAL_STORAGE = 'notebook-storage';
-let currentNotebookObject = null;
+let currentNotebookObjectIdentifier = null;
 let unlisten = null;
 
 function defaultNotebookObjectChanged(newDomainObject) {
     if (newDomainObject.location !== null) {
-        currentNotebookObject = newDomainObject;
-        const notebookStorage = getDefaultNotebook();
-        notebookStorage.domainObject = newDomainObject;
-        saveDefaultNotebook(notebookStorage);
+        currentNotebookObjectIdentifier = newDomainObject.identifier;
 
         return;
     }
@@ -20,10 +19,9 @@ function defaultNotebookObjectChanged(newDomainObject) {
     clearDefaultNotebook();
 }
 
-function observeDefaultNotebookObject(openmct, notebookStorage) {
-    const domainObject = notebookStorage.domainObject;
-    if (currentNotebookObject
-            && currentNotebookObject.identifier.key === domainObject.identifier.key) {
+function observeDefaultNotebookObject(openmct, notebookMeta, domainObject) {
+    if (currentNotebookObjectIdentifier
+            && objectUtils.makeKeyString(currentNotebookObjectIdentifier) === objectUtils.makeKeyString(notebookMeta.identifier)) {
         return;
     }
 
@@ -32,7 +30,7 @@ function observeDefaultNotebookObject(openmct, notebookStorage) {
         unlisten = null;
     }
 
-    unlisten = openmct.objects.observe(notebookStorage.domainObject, '*', defaultNotebookObjectChanged);
+    unlisten = openmct.objects.observe(domainObject, '*', defaultNotebookObjectChanged);
 }
 
 function saveDefaultNotebook(notebookStorage) {
@@ -40,7 +38,7 @@ function saveDefaultNotebook(notebookStorage) {
 }
 
 export function clearDefaultNotebook() {
-    currentNotebookObject = null;
+    currentNotebookObjectIdentifier = null;
     window.localStorage.setItem(NOTEBOOK_LOCAL_STORAGE, null);
 }
 
@@ -50,14 +48,29 @@ export function getDefaultNotebook() {
     return JSON.parse(notebookStorage);
 }
 
-export function setDefaultNotebook(openmct, notebookStorage) {
-    observeDefaultNotebookObject(openmct, notebookStorage);
+export async function getDefaultNotebookLink(openmct, domainObject = null) {
+    if (!domainObject) {
+        return null;
+    }
+
+    const path = await openmct.objects.getOriginalPath(domainObject.identifier)
+        .then(objectPath => objectPath
+            .map(o => o && openmct.objects.makeKeyString(o.identifier))
+            .reverse()
+            .join('/')
+        );
+    const { page, section } = getDefaultNotebook();
+
+    return `#/browse/${path}?sectionId=${section.id}&pageId=${page.id}`;
+}
+
+export function setDefaultNotebook(openmct, notebookStorage, domainObject) {
+    observeDefaultNotebookObject(openmct, notebookStorage, domainObject);
     saveDefaultNotebook(notebookStorage);
 }
 
 export function setDefaultNotebookSection(section) {
     const notebookStorage = getDefaultNotebook();
-
     notebookStorage.section = section;
     saveDefaultNotebook(notebookStorage);
 }

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

@@ -23,14 +23,15 @@
 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: {
@@ -61,7 +62,10 @@ describe('Notebook Storage:', () => {
     beforeEach((done) => {
         openmct = createOpenMct();
         window.localStorage.setItem('notebook-storage', null);
-
+        openmct.objects.addProvider('', jasmine.createSpyObj('mockNotebookProvider', [
+            'create',
+            'update'
+        ]));
         done();
     });
 
@@ -82,7 +86,7 @@ describe('Notebook Storage:', () => {
     });
 
     it('has correct notebookstorage on setDefaultNotebook', () => {
-        NotebookStorage.setDefaultNotebook(openmct, notebookStorage);
+        NotebookStorage.setDefaultNotebook(openmct, notebookStorage, domainObject);
         const defaultNotebook = NotebookStorage.getDefaultNotebook();
 
         expect(JSON.stringify(defaultNotebook)).toBe(JSON.stringify(notebookStorage));
@@ -98,7 +102,7 @@ describe('Notebook Storage:', () => {
             sectionTitle: 'Section'
         };
 
-        NotebookStorage.setDefaultNotebook(openmct, notebookStorage);
+        NotebookStorage.setDefaultNotebook(openmct, notebookStorage, domainObject);
         NotebookStorage.setDefaultNotebookSection(section);
 
         const defaultNotebook = NotebookStorage.getDefaultNotebook();
@@ -115,7 +119,7 @@ describe('Notebook Storage:', () => {
             pageTitle: 'Page'
         };
 
-        NotebookStorage.setDefaultNotebook(openmct, notebookStorage);
+        NotebookStorage.setDefaultNotebook(openmct, notebookStorage, domainObject);
         NotebookStorage.setDefaultNotebookPage(page);
 
         const defaultNotebook = NotebookStorage.getDefaultNotebook();

src/plugins/notificationIndicator/components/NotificationIndicator.vue

@@ -27,10 +27,10 @@
 import NotificationsList from './NotificationsList.vue';
 
 export default {
-    inject: ['openmct'],
     components: {
         NotificationsList
     },
+    inject: ['openmct'],
     data() {
         return {
             notifications: this.openmct.notifications.notifications,

src/plugins/notificationIndicator/plugin.js

@@ -25,12 +25,12 @@ import NotificationIndicator from './components/NotificationIndicator.vue';
 export default function plugin() {
     return function install(openmct) {
         let component = new Vue ({
-            provide: {
-                openmct
-            },
             components: {
                 NotificationIndicator: NotificationIndicator
             },
+            provide: {
+                openmct
+            },
             template: '<NotificationIndicator></NotificationIndicator>'
         });
 

src/plugins/performanceIndicator/README.md

@@ -0,0 +1,9 @@
+# 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

@@ -0,0 +1,62 @@
+/*****************************************************************************
+ * 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

@@ -0,0 +1,87 @@
+/*****************************************************************************
+ * 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/CouchObjectProvider.js

@@ -25,13 +25,36 @@ import CouchObjectQueue from "./CouchObjectQueue";
 
 const REV = "_rev";
 const ID = "_id";
+const HEARTBEAT = 50000;
 
 export default class CouchObjectProvider {
-    constructor(openmct, url, namespace) {
+    // options {
+    //      url: couchdb url,
+    //      disableObserve: disable auto feed from couchdb to keep objects in sync,
+    //      filter: selector to find objects to sync in couchdb
+    //      }
+    constructor(openmct, options, namespace) {
+        options = this._normalize(options);
         this.openmct = openmct;
-        this.url = url;
+        this.url = options.url;
         this.namespace = namespace;
         this.objectQueue = {};
+        this.observeEnabled = options.disableObserve !== true;
+        this.observers = {};
+        if (this.observeEnabled) {
+            this.observeObjectChanges(options.filter);
+        }
+    }
+
+    //backwards compatibility, options used to be a url. Now it's an object
+    _normalize(options) {
+        if (typeof options === 'string') {
+            return {
+                url: options
+            };
+        }
+
+        return options;
     }
 
     request(subPath, method, value) {
@@ -102,6 +125,162 @@ export default class CouchObjectProvider {
         return this.request(identifier.key, "GET").then(this.getModel.bind(this));
     }
 
+    async getObjectsByFilter(filter) {
+        let objects = [];
+
+        let url = `${this.url}/_find`;
+        let body = {};
+
+        if (filter) {
+            body = JSON.stringify(filter);
+        }
+
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body
+        });
+
+        const reader = response.body.getReader();
+        let completed = false;
+
+        while (!completed) {
+            const {done, value} = await reader.read();
+            //done is true when we lose connection with the provider
+            if (done) {
+                completed = true;
+            }
+
+            if (value) {
+                let chunk = new Uint8Array(value.length);
+                chunk.set(value, 0);
+                const decodedChunk = new TextDecoder("utf-8").decode(chunk);
+                try {
+                    const json = JSON.parse(decodedChunk);
+                    if (json) {
+                        let docs = json.docs;
+                        docs.forEach(doc => {
+                            let object = this.getModel(doc);
+                            if (object) {
+                                objects.push(object);
+                            }
+                        });
+                    }
+                } catch (e) {
+                    //do nothing
+                }
+            }
+
+        }
+
+        return objects;
+    }
+
+    observe(identifier, callback) {
+        if (!this.observeEnabled) {
+            return;
+        }
+
+        const keyString = this.openmct.objects.makeKeyString(identifier);
+        this.observers[keyString] = this.observers[keyString] || [];
+        this.observers[keyString].push(callback);
+
+        return () => {
+            this.observers[keyString] = this.observers[keyString].filter(observer => observer !== callback);
+        };
+    }
+
+    abortGetChanges() {
+        if (this.controller) {
+            this.controller.abort();
+            this.controller = undefined;
+        }
+
+        return true;
+    }
+
+    async observeObjectChanges(filter) {
+        let intermediateResponse = this.getIntermediateResponse();
+
+        if (!this.observeEnabled) {
+            intermediateResponse.reject('Observe for changes is disabled');
+        }
+
+        const controller = new AbortController();
+        const signal = controller.signal;
+
+        if (this.controller) {
+            this.abortGetChanges();
+        }
+
+        this.controller = controller;
+        // feed=continuous maintains an indefinitely open connection with a keep-alive of HEARTBEAT milliseconds until this client closes the connection
+        // style=main_only returns only the current winning revision of the document
+        let url = `${this.url}/_changes?feed=continuous&style=main_only&heartbeat=${HEARTBEAT}`;
+
+        let body = {};
+        if (filter) {
+            url = `${url}&filter=_selector`;
+            body = JSON.stringify(filter);
+        }
+
+        const response = await fetch(url, {
+            method: 'POST',
+            signal,
+            headers: {
+                "Content-Type": 'application/json'
+            },
+            body
+        });
+        const reader = response.body.getReader();
+        let completed = false;
+
+        while (!completed) {
+            const {done, value} = await reader.read();
+            //done is true when we lose connection with the provider
+            if (done) {
+                completed = true;
+            }
+
+            if (value) {
+                let chunk = new Uint8Array(value.length);
+                chunk.set(value, 0);
+                const decodedChunk = new TextDecoder("utf-8").decode(chunk).split('\n');
+                if (decodedChunk.length && decodedChunk[decodedChunk.length - 1] === '') {
+                    decodedChunk.forEach((doc, index) => {
+                        try {
+                            const object = JSON.parse(doc);
+                            object.identifier = {
+                                namespace: this.namespace,
+                                key: object.id
+                            };
+                            let keyString = this.openmct.objects.makeKeyString(object.identifier);
+                            let observersForObject = this.observers[keyString];
+
+                            if (observersForObject) {
+                                observersForObject.forEach(async (observer) => {
+                                    const updatedObject = await this.get(object.identifier);
+                                    observer(updatedObject);
+                                });
+                            }
+                        } catch (e) {
+                            //do nothing;
+                        }
+                    });
+                }
+            }
+
+        }
+
+        //We're done receiving from the provider. No more chunks.
+        intermediateResponse.resolve(true);
+
+        return intermediateResponse.promise;
+
+    }
+
     getIntermediateResponse() {
         let intermediateResponse = {};
         intermediateResponse.promise = new Promise(function (resolve, reject) {

src/plugins/persistence/couch/plugin.js

@@ -24,8 +24,9 @@ import CouchObjectProvider from './CouchObjectProvider';
 const NAMESPACE = '';
 const PERSISTENCE_SPACE = 'mct';
 
-export default function CouchPlugin(url) {
+export default function CouchPlugin(options) {
     return function install(openmct) {
-        openmct.objects.addProvider(PERSISTENCE_SPACE, new CouchObjectProvider(openmct, url, NAMESPACE));
+        install.couchProvider = new CouchObjectProvider(openmct, options, NAMESPACE);
+        openmct.objects.addProvider(PERSISTENCE_SPACE, install.couchProvider);
     };
 }

src/plugins/persistence/couch/pluginSpec.js

@@ -32,17 +32,43 @@ describe('the plugin', () => {
     let child;
     let provider;
     let testPath = '/test/db';
+    let options;
+    let mockIdentifierService;
     let mockDomainObject;
 
     beforeEach((done) => {
         mockDomainObject = {
             identifier: {
-                namespace: 'mct',
+                namespace: '',
                 key: 'some-value'
-            }
+            },
+            type: 'mock-type'
+        };
+        options = {
+            url: testPath,
+            filter: {},
+            disableObserve: true
         };
         openmct = createOpenMct(false);
-        openmct.install(new CouchPlugin(testPath));
+
+        spyOnBuiltins(['fetch'], window);
+
+        openmct.$injector = jasmine.createSpyObj('$injector', ['get']);
+        mockIdentifierService = jasmine.createSpyObj(
+            'identifierService',
+            ['parse']
+        );
+        mockIdentifierService.parse.and.returnValue({
+            getSpace: () => {
+                return 'mct';
+            }
+        });
+
+        openmct.$injector.get.and.returnValue(mockIdentifierService);
+
+        openmct.install(new CouchPlugin(options));
+
+        openmct.types.addType('mock-type', {creatable: true});
 
         element = document.createElement('div');
         child = document.createElement('div');
@@ -55,62 +81,67 @@ describe('the plugin', () => {
         spyOn(provider, 'get').and.callThrough();
         spyOn(provider, 'create').and.callThrough();
         spyOn(provider, 'update').and.callThrough();
-
-        spyOnBuiltins(['fetch'], window);
-        fetch.and.returnValue(Promise.resolve({
-            json: () => {
-                return {
-                    ok: true,
-                    _id: 'some-value',
-                    _rev: 1,
-                    model: {}
-                };
-            }
-        }));
     });
 
     afterEach(() => {
         return resetApplicationState(openmct);
     });
 
-    it('gets an object', () => {
-        openmct.objects.get(mockDomainObject.identifier).then((result) => {
-            expect(result.identifier.key).toEqual(mockDomainObject.identifier.key);
+    describe('the provider', () => {
+        let mockPromise;
+        beforeEach(() => {
+            mockPromise = Promise.resolve({
+                json: () => {
+                    return {
+                        ok: true,
+                        _id: 'some-value',
+                        _rev: 1,
+                        model: {}
+                    };
+                }
+            });
+            fetch.and.returnValue(mockPromise);
         });
-    });
 
-    it('creates an object', () => {
-        openmct.objects.save(mockDomainObject).then((result) => {
-            expect(provider.create).toHaveBeenCalled();
-            expect(result).toBeTrue();
-        });
-    });
-
-    it('updates an object', () => {
-        openmct.objects.save(mockDomainObject).then((result) => {
-            expect(result).toBeTrue();
-            expect(provider.create).toHaveBeenCalled();
-            openmct.objects.save(mockDomainObject).then((updatedResult) => {
-                expect(updatedResult).toBeTrue();
-                expect(provider.update).toHaveBeenCalled();
+        it('gets an object', () => {
+            openmct.objects.get(mockDomainObject.identifier).then((result) => {
+                expect(result.identifier.key).toEqual(mockDomainObject.identifier.key);
             });
         });
-    });
 
-    it('updates queued objects', () => {
-        let couchProvider = new CouchObjectProvider(openmct, 'http://localhost', '');
-        let intermediateResponse = couchProvider.getIntermediateResponse();
-        spyOn(couchProvider, 'updateQueued');
-        couchProvider.enqueueObject(mockDomainObject.identifier.key, mockDomainObject, intermediateResponse);
-        couchProvider.objectQueue[mockDomainObject.identifier.key].updateRevision(1);
-        couchProvider.update(mockDomainObject);
-        expect(couchProvider.objectQueue[mockDomainObject.identifier.key].hasNext()).toBe(2);
-        couchProvider.checkResponse({
-            ok: true,
-            rev: 2,
-            id: mockDomainObject.identifier.key
-        }, intermediateResponse);
+        it('creates an object', () => {
+            openmct.objects.save(mockDomainObject).then((result) => {
+                expect(provider.create).toHaveBeenCalled();
+                expect(result).toBeTrue();
+            });
+        });
 
-        expect(couchProvider.updateQueued).toHaveBeenCalledTimes(2);
+        it('updates an object', () => {
+            openmct.objects.save(mockDomainObject).then((result) => {
+                expect(result).toBeTrue();
+                expect(provider.create).toHaveBeenCalled();
+                openmct.objects.save(mockDomainObject).then((updatedResult) => {
+                    expect(updatedResult).toBeTrue();
+                    expect(provider.update).toHaveBeenCalled();
+                });
+            });
+        });
+
+        it('updates queued objects', () => {
+            let couchProvider = new CouchObjectProvider(openmct, options, '');
+            let intermediateResponse = couchProvider.getIntermediateResponse();
+            spyOn(couchProvider, 'updateQueued');
+            couchProvider.enqueueObject(mockDomainObject.identifier.key, mockDomainObject, intermediateResponse);
+            couchProvider.objectQueue[mockDomainObject.identifier.key].updateRevision(1);
+            couchProvider.update(mockDomainObject);
+            expect(couchProvider.objectQueue[mockDomainObject.identifier.key].hasNext()).toBe(2);
+            couchProvider.checkResponse({
+                ok: true,
+                rev: 2,
+                id: mockDomainObject.identifier.key
+            }, intermediateResponse);
+
+            expect(couchProvider.updateQueued).toHaveBeenCalledTimes(2);
+        });
     });
 });

src/plugins/plot/src/inspector/PlotModelFormController.js

@@ -136,7 +136,7 @@ define([
             };
         }
 
-        if (objectPath && !_.isFunction(objectPath)) {
+        if (objectPath && (typeof objectPath !== "function")) {
             const staticObjectPath = objectPath;
             objectPath = function () {
                 return staticObjectPath;

src/plugins/plot/vue/overlayPlot/OverlayPlotViewProvider.js

@@ -0,0 +1,63 @@
+/*****************************************************************************
+ * 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 Plot from '../single/Plot.vue';
+import Vue from 'vue';
+
+export default function OverlayPlotViewProvider(openmct) {
+    return {
+        key: 'plot-overlay',
+        name: 'Overlay Plot',
+        cssClass: 'icon-telemetry',
+        canView(domainObject) {
+            return domainObject.type === 'telemetry.plot.overlay';
+        },
+
+        canEdit(domainObject) {
+            return domainObject.type === 'telemetry.plot.overlay';
+        },
+
+        view: function (domainObject) {
+            let component;
+
+            return {
+                show: function (element) {
+                    component = new Vue({
+                        el: element,
+                        components: {
+                            Plot
+                        },
+                        provide: {
+                            openmct,
+                            domainObject
+                        },
+                        template: '<plot></plot>'
+                    });
+                },
+                destroy: function () {
+                    component.$destroy();
+                    component = undefined;
+                }
+            };
+        }
+    };
+}

src/plugins/plot/vue/single/LinearScale.js

@@ -0,0 +1,83 @@
+/*****************************************************************************
+ * 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.
+ *****************************************************************************/
+/*jscs:disable disallowDanglingUnderscores */
+/**
+ * A scale has an input domain and an output range.  It provides functions
+ * `scale` return the range value associated with a domain value.
+ * `invert` return the domain value associated with range value.
+ */
+
+class LinearScale {
+    constructor(domain) {
+        this.domain(domain);
+    }
+
+    domain(newDomain) {
+        if (newDomain) {
+            this._domain = newDomain;
+            this._domainDenominator = newDomain.max - newDomain.min;
+        }
+
+        return this._domain;
+    }
+
+    range(newRange) {
+        if (newRange) {
+            this._range = newRange;
+            this._rangeDenominator = newRange.max - newRange.min;
+        }
+
+        return this._range;
+    }
+
+    scale(domainValue) {
+        if (!this._domain || !this._range) {
+            return;
+        }
+
+        const domainOffset = domainValue - this._domain.min;
+        const rangeFraction = domainOffset - this._domainDenominator;
+        const rangeOffset = rangeFraction * this._rangeDenominator;
+        const rangeValue = rangeOffset + this._range.min;
+
+        return rangeValue;
+    }
+
+    invert(rangeValue) {
+        if (!this._domain || !this._range) {
+            return;
+        }
+
+        const rangeOffset = rangeValue - this._range.min;
+        const domainFraction = rangeOffset / this._rangeDenominator;
+        const domainOffset = domainFraction * this._domainDenominator;
+        const domainValue = domainOffset + this._domain.min;
+
+        return domainValue;
+    }
+}
+
+export default LinearScale;
+
+/**
+ *
+ */

src/plugins/plot/vue/single/MctPlot.vue

@@ -0,0 +1,892 @@
+<!--
+ 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.
+-->
+<template>
+<div v-if="loaded"
+     class="gl-plot"
+     :class="[plotLegendExpandedStateClass, plotLegendPositionClass]"
+>
+    <plot-legend :cursor-locked="!!lockHighlightPoint"
+                 :series="config.series.models"
+                 :highlights="highlights"
+                 :legend="config.legend"
+    />
+    <div class="plot-wrapper-axis-and-display-area flex-elem grows">
+        <y-axis v-if="config.series.models.length > 0"
+                :tick-width="tickWidth"
+                :single-series="config.series.models.length === 1"
+                :series-model="config.series.models[0]"
+                @yKeyChanged="setYAxisKey"
+                @tickWidthChanged="onTickWidthChange"
+        />
+        <div class="gl-plot-wrapper-display-area-and-x-axis"
+             :style="{
+                 left: (tickWidth + 20) + 'px'
+             }"
+        >
+
+            <div class="gl-plot-display-area has-local-controls has-cursor-guides">
+                <div class="l-state-indicators">
+                    <span class="l-state-indicators__alert-no-lad t-object-alert t-alert-unsynced icon-alert-triangle"
+                          title="This plot is not currently displaying the latest data. Reset pan/zoom to view latest data."
+                    ></span>
+                </div>
+
+                <mct-ticks v-show="gridLines"
+                           :axis-type="'xAxis'"
+                           :position="'right'"
+                           @plotTickWidth="onTickWidthChange"
+                />
+
+                <mct-ticks v-show="gridLines"
+                           :axis-type="'yAxis'"
+                           :position="'bottom'"
+                           @plotTickWidth="onTickWidthChange"
+                />
+
+                <div ref="chartContainer"
+                     class="gl-plot-chart-wrapper"
+                >
+                    <mct-chart :series-config="config"
+                               :rectangles="rectangles"
+                               :highlights="highlights"
+                               @plotReinitializeCanvas="initCanvas"
+                    />
+                </div>
+
+                <div class="gl-plot__local-controls h-local-controls h-local-controls--overlay-content c-local-controls--show-on-hover">
+                    <div class="c-button-set c-button-set--strip-h">
+                        <button class="c-button icon-minus"
+                                title="Zoom out"
+                                @click="zoom('out', 0.2)"
+                        >
+                        </button>
+                        <button class="c-button icon-plus"
+                                title="Zoom in"
+                                @click="zoom('in', 0.2)"
+                        >
+                        </button>
+                    </div>
+                    <div class="c-button-set c-button-set--strip-h"
+                         :disabled="!plotHistory.length"
+                    >
+                        <button class="c-button icon-arrow-left"
+                                title="Restore previous pan/zoom"
+                                @click="back()"
+                        >
+                        </button>
+                        <button class="c-button icon-reset"
+                                title="Reset pan/zoom"
+                                @click="clear()"
+                        >
+                        </button>
+                    </div>
+                </div>
+
+                <!--Cursor guides-->
+                <div v-show="cursorGuide"
+                     ref="cursorGuideVertical"
+                     class="c-cursor-guide--v js-cursor-guide--v"
+                >
+                </div>
+                <div v-show="cursorGuide"
+                     ref="cursorGuideHorizontal"
+                     class="c-cursor-guide--h js-cursor-guide--h"
+                >
+                </div>
+            </div>
+            <x-axis v-if="config.series.models.length > 0"
+                    :series-model="config.series.models[0]"
+            />
+
+        </div>
+    </div>
+
+</div>
+</template>
+
+<script>
+
+import eventHelpers from './lib/eventHelpers';
+import LinearScale from "./LinearScale";
+import PlotConfigurationModel from './configuration/PlotConfigurationModel';
+import configStore from './configuration/configStore';
+
+import PlotLegend from "./legend/PlotLegend.vue";
+import MctTicks from "./MctTicks.vue";
+import MctChart from "./chart/MctChart.vue";
+import XAxis from "./axis/XAxis.vue";
+import YAxis from "./axis/YAxis.vue";
+
+export default {
+    components: {
+        XAxis,
+        YAxis,
+        PlotLegend,
+        MctTicks,
+        MctChart
+    },
+    inject: ['openmct', 'domainObject'],
+    props: {
+        gridLines: {
+            type: Boolean,
+            default() {
+                return true;
+            }
+        },
+        cursorGuide: {
+            type: Boolean,
+            default() {
+                return true;
+            }
+        },
+        plotTickWidth: {
+            type: Number,
+            default() {
+                return 0;
+            }
+        }
+    },
+    data() {
+        return {
+            highlights: [],
+            lockHighlightPoint: false,
+            tickWidth: 0,
+            yKeyOptions: [],
+            yAxisLabel: '',
+            rectangles: [],
+            plotHistory: [],
+            selectedXKeyOption: {},
+            xKeyOptions: [],
+            config: {},
+            pending: 0,
+            loaded: false
+        };
+    },
+    computed: {
+        plotLegendPositionClass() {
+            return `plot-legend-${this.config.legend.get('position')}`;
+        },
+        plotLegendExpandedStateClass() {
+            if (this.config.legend.get('expanded')) {
+                return 'plot-legend-expanded';
+            } else {
+                return 'plot-legend-collapsed';
+            }
+        }
+    },
+    watch: {
+        plotTickWidth(newTickWidth) {
+            this.onTickWidthChange(newTickWidth, true);
+        },
+        gridLines(newGridLines) {
+            this.setGridLinesVisibility(newGridLines);
+        },
+        cursorGuide(newCursorGuide) {
+            this.setCursorGuideVisibility(newCursorGuide);
+        }
+    },
+    mounted() {
+        eventHelpers.extend(this);
+
+        this.config = this.getConfig();
+
+        this.listenTo(this.config.series, 'add', this.addSeries, this);
+        this.listenTo(this.config.series, 'remove', this.removeSeries, this);
+
+        this.config.series.models.forEach(this.addSeries, this);
+
+        this.filterObserver = this.openmct.objects.observe(
+            this.domainObject,
+            'configuration.filters',
+            this.updateFiltersAndResubscribe
+        );
+
+        this.openmct.objectViews.on('clearData', this.clearData);
+        this.followTimeConductor();
+
+        this.loaded = true;
+
+        //We're referencing the canvas elements from the mct-chart in the initialize method.
+        // So we need $nextTick to ensure the component is fully mounted before we can initialize stuff.
+        this.$nextTick(this.initialize);
+
+    },
+    beforeDestroy() {
+        this.destroy();
+    },
+    methods: {
+        followTimeConductor() {
+            this.openmct.time.on('bounds', this.updateDisplayBounds);
+            this.synchronized(true);
+        },
+        getConfig() {
+            const configId = this.openmct.objects.makeKeyString(this.domainObject.identifier);
+            let config = configStore.get(configId);
+            if (!config) {
+                config = new PlotConfigurationModel({
+                    id: configId,
+                    domainObject: this.domainObject,
+                    openmct: this.openmct
+                });
+                configStore.add(configId, config);
+            }
+
+            return config;
+        },
+        addSeries(series) {
+            this.listenTo(series, 'change:xKey', (xKey) => {
+                this.setDisplayRange(series, xKey);
+            }, this);
+            this.listenTo(series, 'change:yKey', () => {
+                this.loadSeriesData(series);
+            }, this);
+
+            this.listenTo(series, 'change:interpolate', () => {
+                this.loadSeriesData(series);
+            }, this);
+
+            this.loadSeriesData(series);
+        },
+
+        removeSeries(plotSeries) {
+            this.stopListening(plotSeries);
+        },
+
+        loadSeriesData(series) {
+            if (this.$parent.$refs.plotWrapper.offsetWidth === 0) {
+                this.scheduleLoad(series);
+
+                return;
+            }
+
+            this.startLoading();
+            const options = {
+                size: this.$parent.$refs.plotWrapper.offsetWidth,
+                domain: this.config.xAxis.get('key')
+            };
+
+            series.load(options)
+                .then(this.stopLoading.bind(this));
+        },
+
+        loadMoreData(range, purge) {
+            this.config.series.forEach(plotSeries => {
+                this.startLoading();
+                plotSeries.load({
+                    size: this.$parent.$refs.plotWrapper.offsetWidth,
+                    start: range.min,
+                    end: range.max,
+                    domain: this.config.xAxis.get('key')
+                })
+                    .then(this.stopLoading());
+                if (purge) {
+                    plotSeries.purgeRecordsOutsideRange(range);
+                }
+            });
+        },
+
+        scheduleLoad(series) {
+            if (!this.scheduledLoads) {
+                this.startLoading();
+                this.scheduledLoads = [];
+                this.checkForSize = setInterval(function () {
+                    if (this.$parent.$refs.plotWrapper.offsetWidth === 0) {
+                        return;
+                    }
+
+                    this.stopLoading();
+                    this.scheduledLoads.forEach(this.loadSeriesData, this);
+                    delete this.scheduledLoads;
+                    clearInterval(this.checkForSize);
+                    delete this.checkForSize;
+                }.bind(this));
+            }
+
+            if (this.scheduledLoads.indexOf(series) === -1) {
+                this.scheduledLoads.push(series);
+            }
+        },
+
+        startLoading() {
+            this.pending += 1;
+            this.updateLoading();
+        },
+
+        stopLoading() {
+        //TODO: Is Vue.$nextTick ok to replace $scope.$evalAsync?
+            this.$nextTick().then(() => {
+                this.pending -= 1;
+                this.updateLoading();
+            });
+        },
+
+        updateLoading() {
+            this.$emit('loadingUpdated', this.pending > 0);
+        },
+
+        updateFiltersAndResubscribe(updatedFilters) {
+            this.config.series.forEach(function (series) {
+                series.updateFiltersAndRefresh(updatedFilters[series.keyString]);
+            });
+        },
+
+        clearData() {
+            this.config.series.forEach(function (series) {
+                series.reset();
+            });
+        },
+
+        setDisplayRange(series, xKey) {
+            if (this.config.series.length !== 1) {
+                return;
+            }
+
+            const displayRange = series.getDisplayRange(xKey);
+            this.config.xAxis.set('range', displayRange);
+        },
+
+        /**
+       * Track latest display bounds.  Forces update when not receiving ticks.
+       */
+        updateDisplayBounds(bounds, isTick) {
+            const newRange = {
+                min: bounds.start,
+                max: bounds.end
+            };
+            this.config.xAxis.set('range', newRange);
+            if (!isTick) {
+                this.skipReloadOnInteraction = true;
+                this.clear();
+                this.skipReloadOnInteraction = false;
+                this.loadMoreData(newRange, true);
+            } else {
+                // Drop any data that is more than 1x (max-min) before min.
+                // Limit these purges to once a second.
+                if (!this.nextPurge || this.nextPurge < Date.now()) {
+                    const keepRange = {
+                        min: newRange.min - (newRange.max - newRange.min),
+                        max: newRange.max
+                    };
+                    this.config.series.forEach(function (series) {
+                        series.purgeRecordsOutsideRange(keepRange);
+                    });
+                    this.nextPurge = Date.now() + 1000;
+                }
+            }
+        },
+
+        /**
+       * Handle end of user viewport change: load more data for current display
+       * bounds, and mark view as synchronized if bounds match configured bounds.
+       */
+        userViewportChangeEnd() {
+            const xDisplayRange = this.config.xAxis.get('displayRange');
+            const xRange = this.config.xAxis.get('range');
+
+            if (!this.skipReloadOnInteraction) {
+                this.loadMoreData(xDisplayRange);
+            }
+
+            this.synchronized(xRange.min === xDisplayRange.min
+            && xRange.max === xDisplayRange.max);
+        },
+
+        /**
+       * Getter/setter for "synchronized" value.  If not synchronized and
+       * time conductor is in clock mode, will mark objects as unsynced so that
+       * displays can update accordingly.
+       */
+        synchronized(value) {
+            if (typeof value !== 'undefined') {
+                this._synchronized = value;
+                const isUnsynced = !value && this.openmct.time.clock();
+                const domainObject = this.openmct.legacyObject(this.domainObject);
+                if (domainObject.getCapability('status')) {
+                    domainObject.getCapability('status')
+                        .set('timeconductor-unsynced', isUnsynced);
+                }
+            }
+
+            return this._synchronized;
+        },
+
+        initCanvas() {
+            if (this.canvas) {
+                this.stopListening(this.canvas);
+            }
+
+            this.canvas = this.$refs.chartContainer.querySelectorAll('canvas')[1];
+
+            this.listenTo(this.canvas, 'mousemove', this.trackMousePosition, this);
+            this.listenTo(this.canvas, 'mouseleave', this.untrackMousePosition, this);
+            this.listenTo(this.canvas, 'mousedown', this.onMouseDown, this);
+            this.listenTo(this.canvas, 'wheel', this.wheelZoom, this);
+        },
+
+        initialize() {
+            // Setup canvas etc.
+            this.xScale = new LinearScale(this.config.xAxis.get('displayRange'));
+            this.yScale = new LinearScale(this.config.yAxis.get('displayRange'));
+
+            this.pan = undefined;
+            this.marquee = undefined;
+
+            this.chartElementBounds = undefined;
+            this.tickUpdate = false;
+
+            this.canvas = this.$refs.chartContainer.querySelectorAll('canvas')[1];
+
+            this.listenTo(this.canvas, 'mousemove', this.trackMousePosition, this);
+            this.listenTo(this.canvas, 'mouseleave', this.untrackMousePosition, this);
+            this.listenTo(this.canvas, 'mousedown', this.onMouseDown, this);
+            this.listenTo(this.canvas, 'wheel', this.wheelZoom, this);
+
+            this.config.yAxisLabel = this.config.yAxis.get('label');
+
+            this.cursorGuideVertical = this.$refs.cursorGuideVertical;
+            this.cursorGuideHorizontal = this.$refs.cursorGuideHorizontal;
+
+            this.listenTo(this.config.xAxis, 'change:displayRange', this.onXAxisChange, this);
+            this.listenTo(this.config.yAxis, 'change:displayRange', this.onYAxisChange, this);
+        },
+
+        onXAxisChange(displayBounds) {
+            if (displayBounds) {
+                this.xScale.domain(displayBounds);
+            }
+        },
+
+        onYAxisChange(displayBounds) {
+            if (displayBounds) {
+                this.yScale.domain(displayBounds);
+            }
+        },
+
+        onTickWidthChange(width, fromDifferentObject) {
+            if (fromDifferentObject) {
+                // Always accept tick width if it comes from a different object.
+                this.tickWidth = width;
+            } else {
+                // Otherwise, only accept tick with if it's larger.
+                const newWidth = Math.max(width, this.tickWidth);
+                if (newWidth !== this.tickWidth) {
+                    this.tickWidth = newWidth;
+                }
+            }
+
+            this.$emit('plotTickWidth', this.tickWidth);
+        },
+
+        trackMousePosition(event) {
+            this.trackChartElementBounds(event);
+            this.xScale.range({
+                min: 0,
+                max: this.chartElementBounds.width
+            });
+            this.yScale.range({
+                min: 0,
+                max: this.chartElementBounds.height
+            });
+
+            this.positionOverElement = {
+                x: event.clientX - this.chartElementBounds.left,
+                y: this.chartElementBounds.height
+              - (event.clientY - this.chartElementBounds.top)
+            };
+
+            this.positionOverPlot = {
+                x: this.xScale.invert(this.positionOverElement.x),
+                y: this.yScale.invert(this.positionOverElement.y)
+            };
+
+            if (this.cursorGuide) {
+                this.updateCrosshairs(event);
+            }
+
+            this.highlightValues(this.positionOverPlot.x);
+            this.updateMarquee();
+            this.updatePan();
+            event.preventDefault();
+        },
+
+        updateCrosshairs(event) {
+            this.cursorGuideVertical.style.left = (event.clientX - this.chartElementBounds.x) + 'px';
+            this.cursorGuideHorizontal.style.top = (event.clientY - this.chartElementBounds.y) + 'px';
+        },
+
+        trackChartElementBounds(event) {
+            if (event.target === this.canvas) {
+                this.chartElementBounds = event.target.getBoundingClientRect();
+            }
+        },
+
+        onPlotHighlightSet($e, point) {
+            if (point === this.highlightPoint) {
+                return;
+            }
+
+            this.highlightValues(point);
+        },
+
+        highlightValues(point) {
+            this.highlightPoint = point;
+            // TODO: used in StackedPlotController
+            this.$emit('plotHighlightUpdate', point);
+            if (this.lockHighlightPoint) {
+                return;
+            }
+
+            if (!point) {
+                this.highlights = [];
+                this.config.series.models.forEach(series => delete series.closest);
+            } else {
+                this.highlights = this.config.series.models
+                    .filter(series => series.data.length > 0)
+                    .map(series => {
+                        series.closest = series.nearestPoint(point);
+
+                        return {
+                            series: series,
+                            point: series.closest
+                        };
+                    });
+            }
+        },
+
+        untrackMousePosition() {
+            this.positionOverElement = undefined;
+            this.positionOverPlot = undefined;
+            this.highlightValues();
+        },
+
+        onMouseDown(event) {
+        // do not monitor drag events on browser context click
+            if (event.ctrlKey) {
+                return;
+            }
+
+            this.listenTo(window, 'mouseup', this.onMouseUp, this);
+            this.listenTo(window, 'mousemove', this.trackMousePosition, this);
+            if (event.altKey) {
+                return this.startPan(event);
+            } else {
+                return this.startMarquee(event);
+            }
+        },
+
+        onMouseUp(event) {
+            this.stopListening(window, 'mouseup', this.onMouseUp, this);
+            this.stopListening(window, 'mousemove', this.trackMousePosition, this);
+
+            if (this.isMouseClick()) {
+                this.lockHighlightPoint = !this.lockHighlightPoint;
+            }
+
+            if (this.pan) {
+                return this.endPan(event);
+            }
+
+            if (this.marquee) {
+                return this.endMarquee(event);
+            }
+        },
+
+        isMouseClick() {
+            if (!this.marquee) {
+                return false;
+            }
+
+            const { start, end } = this.marquee;
+
+            return start.x === end.x && start.y === end.y;
+        },
+
+        updateMarquee() {
+            if (!this.marquee) {
+                return;
+            }
+
+            this.marquee.end = this.positionOverPlot;
+            this.marquee.endPixels = this.positionOverElement;
+        },
+
+        startMarquee(event) {
+            this.canvas.classList.remove('plot-drag');
+            this.canvas.classList.add('plot-marquee');
+
+            this.trackMousePosition(event);
+            if (this.positionOverPlot) {
+                this.freeze();
+                this.marquee = {
+                    startPixels: this.positionOverElement,
+                    endPixels: this.positionOverElement,
+                    start: this.positionOverPlot,
+                    end: this.positionOverPlot,
+                    color: [1, 1, 1, 0.5]
+                };
+                this.rectangles.push(this.marquee);
+                this.trackHistory();
+            }
+        },
+
+        endMarquee() {
+            const startPixels = this.marquee.startPixels;
+            const endPixels = this.marquee.endPixels;
+            const marqueeDistance = Math.sqrt(
+                Math.pow(startPixels.x - endPixels.x, 2)
+            + Math.pow(startPixels.y - endPixels.y, 2)
+            );
+            // Don't zoom if mouse moved less than 7.5 pixels.
+            if (marqueeDistance > 7.5) {
+                this.config.xAxis.set('displayRange', {
+                    min: Math.min(this.marquee.start.x, this.marquee.end.x),
+                    max: Math.max(this.marquee.start.x, this.marquee.end.x)
+                });
+                this.config.yAxis.set('displayRange', {
+                    min: Math.min(this.marquee.start.y, this.marquee.end.y),
+                    max: Math.max(this.marquee.start.y, this.marquee.end.y)
+                });
+                this.userViewportChangeEnd();
+            } else {
+                // A history entry is created by startMarquee, need to remove
+                // if marquee zoom doesn't occur.
+                this.plotHistory.pop();
+            }
+
+            this.rectangles = [];
+            this.marquee = undefined;
+        },
+
+        zoom(zoomDirection, zoomFactor) {
+            const currentXaxis = this.config.xAxis.get('displayRange');
+            const currentYaxis = this.config.yAxis.get('displayRange');
+
+            // when there is no plot data, the ranges can be undefined
+            // in which case we should not perform zoom
+            if (!currentXaxis || !currentYaxis) {
+                return;
+            }
+
+            this.freeze();
+            this.trackHistory();
+
+            const xAxisDist = (currentXaxis.max - currentXaxis.min) * zoomFactor;
+            const yAxisDist = (currentYaxis.max - currentYaxis.min) * zoomFactor;
+
+            if (zoomDirection === 'in') {
+                this.config.xAxis.set('displayRange', {
+                    min: currentXaxis.min + xAxisDist,
+                    max: currentXaxis.max - xAxisDist
+                });
+
+                this.config.yAxis.set('displayRange', {
+                    min: currentYaxis.min + yAxisDist,
+                    max: currentYaxis.max - yAxisDist
+                });
+            } else if (zoomDirection === 'out') {
+                this.config.xAxis.set('displayRange', {
+                    min: currentXaxis.min - xAxisDist,
+                    max: currentXaxis.max + xAxisDist
+                });
+
+                this.config.yAxis.set('displayRange', {
+                    min: currentYaxis.min - yAxisDist,
+                    max: currentYaxis.max + yAxisDist
+                });
+            }
+
+            this.userViewportChangeEnd();
+        },
+
+        wheelZoom(event) {
+            const ZOOM_AMT = 0.1;
+            event.preventDefault();
+
+            if (!this.positionOverPlot) {
+                return;
+            }
+
+            let xDisplayRange = this.config.xAxis.get('displayRange');
+            let yDisplayRange = this.config.yAxis.get('displayRange');
+
+            // when there is no plot data, the ranges can be undefined
+            // in which case we should not perform zoom
+            if (!xDisplayRange || !yDisplayRange) {
+                return;
+            }
+
+            this.freeze();
+            window.clearTimeout(this.stillZooming);
+
+            let xAxisDist = (xDisplayRange.max - xDisplayRange.min);
+            let yAxisDist = (yDisplayRange.max - yDisplayRange.min);
+            let xDistMouseToMax = xDisplayRange.max - this.positionOverPlot.x;
+            let xDistMouseToMin = this.positionOverPlot.x - xDisplayRange.min;
+            let yDistMouseToMax = yDisplayRange.max - this.positionOverPlot.y;
+            let yDistMouseToMin = this.positionOverPlot.y - yDisplayRange.min;
+            let xAxisMaxDist = xDistMouseToMax / xAxisDist;
+            let xAxisMinDist = xDistMouseToMin / xAxisDist;
+            let yAxisMaxDist = yDistMouseToMax / yAxisDist;
+            let yAxisMinDist = yDistMouseToMin / yAxisDist;
+
+            let plotHistoryStep;
+
+            if (!plotHistoryStep) {
+                plotHistoryStep = {
+                    x: xDisplayRange,
+                    y: yDisplayRange
+                };
+            }
+
+            if (event.wheelDelta < 0) {
+
+                this.config.xAxis.set('displayRange', {
+                    min: xDisplayRange.min + ((xAxisDist * ZOOM_AMT) * xAxisMinDist),
+                    max: xDisplayRange.max - ((xAxisDist * ZOOM_AMT) * xAxisMaxDist)
+                });
+
+                this.config.yAxis.set('displayRange', {
+                    min: yDisplayRange.min + ((yAxisDist * ZOOM_AMT) * yAxisMinDist),
+                    max: yDisplayRange.max - ((yAxisDist * ZOOM_AMT) * yAxisMaxDist)
+                });
+            } else if (event.wheelDelta >= 0) {
+
+                this.config.xAxis.set('displayRange', {
+                    min: xDisplayRange.min - ((xAxisDist * ZOOM_AMT) * xAxisMinDist),
+                    max: xDisplayRange.max + ((xAxisDist * ZOOM_AMT) * xAxisMaxDist)
+                });
+
+                this.config.yAxis.set('displayRange', {
+                    min: yDisplayRange.min - ((yAxisDist * ZOOM_AMT) * yAxisMinDist),
+                    max: yDisplayRange.max + ((yAxisDist * ZOOM_AMT) * yAxisMaxDist)
+                });
+            }
+
+            this.stillZooming = window.setTimeout(function () {
+                this.plotHistory.push(plotHistoryStep);
+                plotHistoryStep = undefined;
+                this.userViewportChangeEnd();
+            }.bind(this), 250);
+        },
+
+        startPan(event) {
+            this.canvas.classList.add('plot-drag');
+            this.canvas.classList.remove('plot-marquee');
+
+            this.trackMousePosition(event);
+            this.freeze();
+            this.pan = {
+                start: this.positionOverPlot
+            };
+            event.preventDefault();
+            this.trackHistory();
+
+            return false;
+        },
+
+        updatePan() {
+        // calculate offset between points.  Apply that offset to viewport.
+            if (!this.pan) {
+                return;
+            }
+
+            const dX = this.pan.start.x - this.positionOverPlot.x;
+            const dY = this.pan.start.y - this.positionOverPlot.y;
+            const xRange = this.config.xAxis.get('displayRange');
+            const yRange = this.config.yAxis.get('displayRange');
+
+            this.config.xAxis.set('displayRange', {
+                min: xRange.min + dX,
+                max: xRange.max + dX
+            });
+            this.config.yAxis.set('displayRange', {
+                min: yRange.min + dY,
+                max: yRange.max + dY
+            });
+        },
+
+        trackHistory() {
+            this.plotHistory.push({
+                x: this.config.xAxis.get('displayRange'),
+                y: this.config.yAxis.get('displayRange')
+            });
+        },
+
+        endPan() {
+            this.pan = undefined;
+            this.userViewportChangeEnd();
+        },
+
+        freeze() {
+            this.config.yAxis.set('frozen', true);
+            this.config.xAxis.set('frozen', true);
+        },
+
+        clear() {
+            this.config.yAxis.set('frozen', false);
+            this.config.xAxis.set('frozen', false);
+            this.plotHistory = [];
+            this.userViewportChangeEnd();
+        },
+
+        back() {
+            const previousAxisRanges = this.plotHistory.pop();
+            if (this.plotHistory.length === 0) {
+                this.clear();
+
+                return;
+            }
+
+            this.config.xAxis.set('displayRange', previousAxisRanges.x);
+            this.config.yAxis.set('displayRange', previousAxisRanges.y);
+            this.userViewportChangeEnd();
+        },
+
+        setCursorGuideVisibility(cursorGuide) {
+            this.cursorGuide = cursorGuide === true;
+        },
+
+        setGridLinesVisibility(gridLines) {
+            this.gridLines = gridLines === true;
+        },
+
+        setYAxisKey(yKey) {
+            this.config.series.models[0].emit('change:yKey', yKey);
+        },
+
+        destroy() {
+            configStore.deleteStore(this.config.id);
+
+            this.stopListening();
+            if (this.checkForSize) {
+                clearInterval(this.checkForSize);
+                delete this.checkForSize;
+            }
+
+            if (this.filterObserver) {
+                this.filterObserver();
+            }
+        }
+    }
+};
+
+</script>

src/plugins/plot/vue/single/MctTicks.vue

@@ -0,0 +1,269 @@
+<!--
+ 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.
+-->
+
+<template>
+<div ref="tickContainer"
+     class="u-contents js-ticks"
+>
+    <div v-if="position === 'left'"
+         class="gl-plot-tick-wrapper"
+    >
+        <div v-for="tick in ticks"
+             :key="tick.value"
+             class="gl-plot-tick gl-plot-x-tick-label"
+             :style="{
+                 left: (100 * (tick.value - min) / interval) + '%'
+             }"
+             :title="tick.fullText || tick.text"
+        >
+            {{ tick.text }}
+        </div>
+    </div>
+    <div v-if="position === 'top'"
+         class="gl-plot-tick-wrapper"
+    >
+        <div v-for="tick in ticks"
+             :key="tick.value"
+             class="gl-plot-tick gl-plot-y-tick-label"
+             :style="{ top: (100 * (max - tick.value) / interval) + '%' }"
+             :title="tick.fullText || tick.text"
+             style="margin-top: -0.50em; direction: ltr;"
+        >
+            <span>{{ tick.text }}</span>
+        </div>
+    </div>
+    <!-- grid lines follow -->
+    <template v-if="position === 'right'">
+        <div v-for="tick in ticks"
+             :key="tick.value"
+             class="gl-plot-hash hash-v"
+             :style="{
+                 right: (100 * (max - tick.value) / interval) + '%',
+                 height: '100%'
+             }"
+        >
+        </div>
+    </template>
+    <template v-if="position === 'bottom'">
+        <div v-for="tick in ticks"
+             :key="tick.value"
+             class="gl-plot-hash hash-h"
+             :style="{ bottom: (100 * (tick.value - min) / interval) + '%', width: '100%' }"
+        >
+        </div>
+    </template>
+</div>
+</template>
+
+<script>
+import eventHelpers from "./lib/eventHelpers";
+import { ticks, commonPrefix, commonSuffix } from "./tickUtils";
+import configStore from "./configuration/configStore";
+
+export default {
+    inject: ['openmct', 'domainObject'],
+    props: {
+        axisType: {
+            type: String,
+            default() {
+                return '';
+            },
+            required: true
+        },
+        position: {
+            required: true,
+            type: String,
+            default() {
+                return '';
+            }
+        }
+    },
+    data() {
+        return {
+            ticks: []
+        };
+    },
+    mounted() {
+        eventHelpers.extend(this);
+
+        this.axis = this.getAxisFromConfig();
+
+        this.tickCount = 4;
+        this.tickUpdate = false;
+        this.listenTo(this.axis, 'change:displayRange', this.updateTicks, this);
+        this.listenTo(this.axis, 'change:format', this.updateTicks, this);
+        this.listenTo(this.axis, 'change:key', this.updateTicksForceRegeneration, this);
+        this.updateTicks();
+    },
+    beforeDestroy() {
+        this.stopListening();
+    },
+    methods: {
+        getAxisFromConfig() {
+            if (!this.axisType) {
+                return;
+            }
+
+            const configId = this.openmct.objects.makeKeyString(this.domainObject.identifier);
+            let config = configStore.get(configId);
+            if (config) {
+                return config[this.axisType];
+            }
+        },
+        /**
+       * Determine whether ticks should be regenerated for a given range.
+       * Ticks are updated
+       * a) if they don't exist,
+       * b) if existing ticks are outside of given range,
+       * c) if range exceeds size of tick range by more than one tick step,
+       * d) if forced to regenerate (ex. changing x-axis metadata).
+       *
+       */
+        shouldRegenerateTicks(range, forceRegeneration) {
+            if (forceRegeneration) {
+                return true;
+            }
+
+            if (!this.tickRange || !this.ticks || !this.ticks.length) {
+                return true;
+            }
+
+            if (this.tickRange.max > range.max || this.tickRange.min < range.min) {
+                return true;
+            }
+
+            if (Math.abs(range.max - this.tickRange.max) > this.tickRange.step) {
+                return true;
+            }
+
+            if (Math.abs(this.tickRange.min - range.min) > this.tickRange.step) {
+                return true;
+            }
+
+            return false;
+        },
+
+        getTicks() {
+            const number = this.tickCount;
+            const clampRange = this.axis.get('values');
+            const range = this.axis.get('displayRange');
+            if (clampRange) {
+                return clampRange.filter(function (value) {
+                    return value <= range.max && value >= range.min;
+                }, this);
+            }
+
+            return ticks(range.min, range.max, number);
+        },
+
+        updateTicksForceRegeneration() {
+            this.updateTicks(true);
+        },
+
+        updateTicks(forceRegeneration = false) {
+            const range = this.axis.get('displayRange');
+            if (!range) {
+                delete this.min;
+                delete this.max;
+                delete this.interval;
+                delete this.tickRange;
+                this.ticks = [];
+                delete this.shouldCheckWidth;
+
+                return;
+            }
+
+            const format = this.axis.get('format');
+            if (!format) {
+                return;
+            }
+
+            this.min = range.min;
+            this.max = range.max;
+            this.interval = Math.abs(range.min - range.max);
+            if (this.shouldRegenerateTicks(range, forceRegeneration)) {
+                let newTicks = this.getTicks();
+                this.tickRange = {
+                    min: Math.min.apply(Math, newTicks),
+                    max: Math.max.apply(Math, newTicks),
+                    step: newTicks[1] - newTicks[0]
+                };
+
+                newTicks = newTicks
+                    .map(function (tickValue) {
+                        return {
+                            value: tickValue,
+                            text: format(tickValue)
+                        };
+                    }, this);
+
+                if (newTicks.length && typeof newTicks[0].text === 'string') {
+                    const tickText = newTicks.map(function (t) {
+                        return t.text;
+                    });
+                    const prefix = tickText.reduce(commonPrefix);
+                    const suffix = tickText.reduce(commonSuffix);
+                    newTicks.forEach(function (t) {
+                        t.fullText = t.text;
+                        if (suffix.length) {
+                            t.text = t.text.slice(prefix.length, -suffix.length);
+                        } else {
+                            t.text = t.text.slice(prefix.length);
+                        }
+                    });
+                }
+
+                this.ticks = newTicks;
+                this.shouldCheckWidth = true;
+            }
+
+            this.scheduleTickUpdate();
+        },
+
+        scheduleTickUpdate() {
+            if (this.tickUpdate) {
+                return;
+            }
+
+            this.tickUpdate = true;
+            setTimeout(this.doTickUpdate.bind(this), 0);
+        },
+
+        doTickUpdate() {
+            if (this.shouldCheckWidth) {
+                const tickElements = this.$refs.tickContainer.querySelectorAll('.gl-plot-tick > span');
+
+                const tickWidth = Number([].reduce.call(tickElements, function (memo, first) {
+                    return Math.max(memo, first.offsetWidth);
+                }, 0));
+
+                this.tickWidth = tickWidth;
+                this.$emit('plotTickWidth', tickWidth);
+                this.shouldCheckWidth = false;
+            }
+
+            this.tickUpdate = false;
+        }
+    }
+};
+
+</script>

src/plugins/plot/vue/single/Plot.vue

@@ -0,0 +1,125 @@
+<!--
+ 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.
+-->
+<template>
+<div ref="plotWrapper"
+     class="c-plot holder holder-plot has-control-bar"
+>
+    <div class="c-control-bar">
+        <span class="c-button-set c-button-set--strip-h">
+            <button class="c-button icon-download"
+                    title="Export This View's Data as PNG"
+                    @click="exportPNG()"
+            >
+                <span class="c-button__label">PNG</span>
+            </button>
+            <button class="c-button"
+                    title="Export This View's Data as JPG"
+                    @click="exportJPG()"
+            >
+                <span class="c-button__label">JPG</span>
+            </button>
+        </span>
+        <button class="c-button icon-crosshair"
+                :class="{ 'is-active': cursorGuide }"
+                title="Toggle cursor guides"
+                @click="toggleCursorGuide"
+        >
+        </button>
+        <button class="c-button"
+                :class="{ 'icon-grid-on': gridLines, 'icon-grid-off': !gridLines }"
+                title="Toggle grid lines"
+                @click="toggleGridLines"
+        >
+        </button>
+    </div>
+
+    <div ref="plotContainer"
+         class="l-view-section u-style-receiver js-style-receiver"
+    >
+        <div v-show="!!loading"
+             class="c-loading--overlay loading"
+        ></div>
+        <mct-plot :grid-lines="gridLines"
+                  :cursor-guide="cursorGuide"
+                  @loadingUpdated="loadingUpdated"
+        />
+    </div>
+</div>
+</template>
+
+<script>
+import eventHelpers from "./lib/eventHelpers";
+import MctPlot from './MctPlot.vue';
+
+export default {
+    components: {
+        MctPlot
+    },
+    inject: ['openmct', 'domainObject'],
+    data() {
+        return {
+            //Don't think we need this as it appears to be stacked plot specific
+            // hideExportButtons: false
+            cursorGuide: false,
+            gridLines: true,
+            loading: false
+        };
+    },
+    mounted() {
+        eventHelpers.extend(this);
+
+        this.exportImageService = this.openmct.$injector.get('exportImageService');
+    },
+    beforeDestroy() {
+        this.destroy();
+    },
+    methods: {
+        loadingUpdated(loading) {
+            this.loading = loading;
+        },
+        destroy() {
+            this.stopListening();
+        },
+
+        exportJPG() {
+            const plotElement = this.$refs.plotContainer;
+
+            this.exportImageService.exportJPG(plotElement, 'plot.jpg', 'export-plot');
+        },
+
+        exportPNG() {
+            const plotElement = this.$refs.plotContainer;
+
+            this.exportImageService.exportPNG(plotElement, 'plot.png', 'export-plot');
+        },
+
+        toggleCursorGuide() {
+            this.cursorGuide = !this.cursorGuide;
+        },
+
+        toggleGridLines() {
+            this.gridLines = !this.gridLines;
+        }
+    }
+};
+
+</script>