merge with master

add tests for actionsAPI
remove focused describe
2020-11-03 13:48:28 -08:00 · 2020-11-03 13:43:45 -08:00 · 2020-11-02 11:09:59 -08:00 · 2020-11-02 11:06:59 -08:00 · 2020-10-29 15:24:51 -07:00 · 2020-10-20 16:54:53 -07:00
112 changed files with 2451 additions and 4329 deletions
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -182,7 +182,7 @@ The following guidelines are provided for anyone contributing source code to the
 1. Avoid the use of "magic" values.
   eg.
   ```JavaScript
-   const UNAUTHORIZED = 401;
+   Const UNAUTHORIZED = 401
   if (responseCode === UNAUTHORIZED)
   ```
   is preferable to
--- a/index.html
+++ b/index.html
@@ -30,38 +30,6 @@
        <link rel="icon" type="image/png" href="dist/favicons/favicon-96x96.png" sizes="96x96" type="image/x-icon">
        <link rel="icon" type="image/png" href="dist/favicons/favicon-32x32.png" sizes="32x32" type="image/x-icon">
        <link rel="icon" type="image/png" href="dist/favicons/favicon-16x16.png" sizes="16x16" type="image/x-icon">
-        <style type="text/css">
-            @keyframes splash-spinner {
-                0% {
-                    transform: translate(-50%, -50%) rotate(0deg); }
-                100% {
-                    transform: translate(-50%, -50%) rotate(360deg); } }
-
-            #splash-screen {
-                background-color: black;
-                position: absolute;
-                top: 0; right: 0; bottom: 0; left: 0;
-                z-index: 10000;
-            }
-
-            #splash-screen:before {
-                animation-name: splash-spinner;
-                animation-duration: 0.5s;
-                animation-iteration-count: infinite;
-                animation-timing-function: linear;
-                border-radius: 50%;
-                border-color: rgba(255,255,255,0.25);
-                border-top-color: white;
-                border-style: solid;
-                border-width: 10px;
-                content: '';
-                display: block;
-                opacity: 0.25;
-                position: absolute;
-                left: 50%; top: 50%;
-                height: 100px; width: 100px;
-            }
-        </style>
    </head>
    <body>
    </body>
@@ -131,10 +99,10 @@
                        }
                    ],
                    // maximum recent bounds to retain in conductor history
-                    records: 10
+                    records: 10,
                    // maximum duration between start and end bounds
                    // for utc-based time systems this is in milliseconds
-                    // limit: ONE_DAY
+                    limit: ONE_DAY
                },
                {
                    name: "Realtime",
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "openmct",
-  "version": "1.5.0-SNAPSHOT",
+  "version": "1.3.3-SNAPSHOT",
  "description": "The Open MCT core platform",
  "dependencies": {},
  "devDependencies": {
--- a/platform/commonUI/general/res/templates/label.html
+++ b/platform/commonUI/general/res/templates/label.html
@@ -20,12 +20,12 @@
 at runtime from the About dialog for additional information.
 -->
 <div class="c-object-label"
-     ng-class="{ 'is-status--missing': model.status === 'missing' }"
+     ng-class="{ 'is-missing': model.status === 'missing' }"
 >
    <div class="c-object-label__type-icon {{type.getCssClass()}}"
         ng-class="{ 'l-icon-link':location.isLink() }"
    >
-        <span class="is-status__indicator" title="This item is missing or suspect"></span>
+        <span class="is-missing__indicator" title="This item is missing"></span>
    </div>
    <div class='c-object-label__name'>{{model.name}}</div>
 </div>
--- a/platform/entanglement/bundle.js
+++ b/platform/entanglement/bundle.js
@@ -21,24 +21,32 @@
 *****************************************************************************/

 define([
+    "./src/actions/MoveAction",
+    "./src/actions/CopyAction",
    "./src/actions/LinkAction",
    "./src/actions/SetPrimaryLocationAction",
    "./src/services/LocatingCreationDecorator",
    "./src/services/LocatingObjectDecorator",
    "./src/policies/CopyPolicy",
    "./src/policies/CrossSpacePolicy",
+    "./src/policies/MovePolicy",
    "./src/capabilities/LocationCapability",
+    "./src/services/MoveService",
    "./src/services/LinkService",
    "./src/services/CopyService",
    "./src/services/LocationService"
 ], function (
+    MoveAction,
+    CopyAction,
    LinkAction,
    SetPrimaryLocationAction,
    LocatingCreationDecorator,
    LocatingObjectDecorator,
    CopyPolicy,
    CrossSpacePolicy,
+    MovePolicy,
    LocationCapability,
+    MoveService,
    LinkService,
    CopyService,
    LocationService
@@ -52,6 +60,39 @@ define([
            "configuration": {},
            "extensions": {
                "actions": [
+                    {
+                        "key": "move",
+                        "name": "Move",
+                        "description": "Move object to another location.",
+                        "cssClass": "icon-move",
+                        "category": "contextual",
+                        "group": "action",
+                        "priority": 9,
+                        "implementation": MoveAction,
+                        "depends": [
+                            "policyService",
+                            "locationService",
+                            "moveService"
+                        ]
+                    },
+                    {
+                        "key": "copy",
+                        "name": "Duplicate",
+                        "description": "Duplicate object to another location.",
+                        "cssClass": "icon-duplicate",
+                        "category": "contextual",
+                        "group": "action",
+                        "priority": 8,
+                        "implementation": CopyAction,
+                        "depends": [
+                            "$log",
+                            "policyService",
+                            "locationService",
+                            "copyService",
+                            "dialogService",
+                            "notificationService"
+                        ]
+                    },
                    {
                        "key": "link",
                        "name": "Create Link",
@@ -100,6 +141,10 @@ define([
                    {
                        "category": "action",
                        "implementation": CopyPolicy
+                    },
+                    {
+                        "category": "action",
+                        "implementation": MovePolicy
                    }
                ],
                "capabilities": [
@@ -115,6 +160,17 @@ define([
                    }
                ],
                "services": [
+                    {
+                        "key": "moveService",
+                        "name": "Move Service",
+                        "description": "Provides a service for moving objects",
+                        "implementation": MoveService,
+                        "depends": [
+                            "openmct",
+                            "linkService",
+                            "$q"
+                        ]
+                    },
                    {
                        "key": "linkService",
                        "name": "Link Service",
--- a/platform/entanglement/src/actions/CopyAction.js
+++ b/platform/entanglement/src/actions/CopyAction.js
@@ -0,0 +1,168 @@
+/*****************************************************************************
+ * 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(
+    ['./AbstractComposeAction', './CancelError'],
+    function (AbstractComposeAction, CancelError) {
+
+        /**
+         * The CopyAction is available from context menus and allows a user to
+         * deep copy an object to another location of their choosing.
+         *
+         * @implements {Action}
+         * @constructor
+         * @memberof platform/entanglement
+         */
+        function CopyAction(
+            $log,
+            policyService,
+            locationService,
+            copyService,
+            dialogService,
+            notificationService,
+            context
+        ) {
+            this.dialog = undefined;
+            this.notification = undefined;
+            this.dialogService = dialogService;
+            this.notificationService = notificationService;
+            this.$log = $log;
+            //Extend the behaviour of the Abstract Compose Action
+            AbstractComposeAction.call(
+                this,
+                policyService,
+                locationService,
+                copyService,
+                context,
+                "Duplicate",
+                "To a Location"
+            );
+        }
+
+        CopyAction.prototype = Object.create(AbstractComposeAction.prototype);
+
+        /**
+         * Updates user about progress of copy. Should not be invoked by
+         * client code under any circumstances.
+         *
+         * @private
+         * @param phase
+         * @param totalObjects
+         * @param processed
+         */
+        CopyAction.prototype.progress = function (phase, totalObjects, processed) {
+            /*
+             Copy has two distinct phases. In the first phase a copy plan is
+             made in memory. During this phase of execution, the user is
+             shown a blocking 'modal' dialog.
+
+             In the second phase, the copying is taking place, and the user
+             is shown non-invasive banner notifications at the bottom of the screen.
+             */
+            if (phase.toLowerCase() === 'preparing' && !this.dialog) {
+                this.dialog = this.dialogService.showBlockingMessage({
+                    title: "Preparing to copy objects",
+                    hint: "Do not navigate away from this page or close this browser tab while this message is displayed.",
+                    unknownProgress: true,
+                    severity: "info"
+                });
+            } else if (phase.toLowerCase() === "copying") {
+                if (this.dialog) {
+                    this.dialog.dismiss();
+                }
+
+                if (!this.notification) {
+                    this.notification = this.notificationService
+                        .notify({
+                            title: "Copying objects",
+                            unknownProgress: false,
+                            severity: "info"
+                        });
+                }
+
+                this.notification.model.progress = (processed / totalObjects) * 100;
+                this.notification.model.title = ["Copied ", processed, "of ",
+                    totalObjects, "objects"].join(" ");
+            }
+        };
+
+        /**
+         * Executes the CopyAction. The CopyAction uses the default behaviour of
+         * the AbstractComposeAction, but extends it to support notification
+         * updates of progress on copy.
+         */
+        CopyAction.prototype.perform = function () {
+            var self = this;
+
+            function success(domainObject) {
+                var domainObjectName = domainObject.model.name;
+
+                self.notification.dismiss();
+                self.notificationService.info(domainObjectName + " copied successfully.");
+            }
+
+            function error(errorDetails) {
+                // No need to notify user of their own cancellation
+                if (errorDetails instanceof CancelError) {
+                    return;
+                }
+
+                var errorDialog,
+                    errorMessage = {
+                        title: "Error copying objects.",
+                        severity: "error",
+                        hint: errorDetails.message,
+                        minimized: true, // want the notification to be minimized initially (don't show banner)
+                        options: [{
+                            label: "OK",
+                            callback: function () {
+                                errorDialog.dismiss();
+                            }
+                        }]
+                    };
+
+                self.dialog.dismiss();
+                if (self.notification) {
+                    self.notification.dismiss(); // Clear the progress notification
+                }
+
+                self.$log.error("Error copying objects. ", errorDetails);
+                //Show a minimized notification of error for posterity
+                self.notificationService.notify(errorMessage);
+                //Display a blocking message
+                errorDialog = self.dialogService.showBlockingMessage(errorMessage);
+
+            }
+
+            function notification(details) {
+                self.progress(details.phase, details.totalObjects, details.processed);
+            }
+
+            return AbstractComposeAction.prototype.perform.call(this)
+                .then(success, error, notification);
+        };
+
+        CopyAction.appliesTo = AbstractComposeAction.appliesTo;
+
+        return CopyAction;
+    }
+);
--- a/src/plugins/interceptors/missingObjectInterceptor.js
+++ b/src/plugins/interceptors/missingObjectInterceptor.js
@@ -20,21 +20,40 @@
 * at runtime from the About dialog for additional information.
 *****************************************************************************/

-export default function MissingObjectInterceptor(openmct) {
-    openmct.objects.addGetInterceptor({
-        appliesTo: (identifier, domainObject) => {
-            return identifier.key !== 'mine';
-        },
-        invoke: (identifier, object) => {
-            if (object === undefined) {
-                return {
-                    identifier,
-                    type: 'unknown',
-                    name: 'Missing: ' + openmct.objects.makeKeyString(identifier)
-                };
+define(
+    ['./AbstractComposeAction'],
+    function (AbstractComposeAction) {
+
+        /**
+         * The MoveAction is available from context menus and allows a user to
+         * move an object to another location of their choosing.
+         *
+         * @implements {Action}
+         * @constructor
+         * @memberof platform/entanglement
+         */
+        function MoveAction(policyService, locationService, moveService, context) {
+            AbstractComposeAction.apply(
+                this,
+                [policyService, locationService, moveService, context, "Move"]
+            );
+        }
+
+        MoveAction.prototype = Object.create(AbstractComposeAction.prototype);
+
+        MoveAction.appliesTo = function (context) {
+            var applicableObject =
+                context.selectedObject || context.domainObject;
+
+            if (applicableObject && applicableObject.model.locked) {
+                return false;
            }

-            return object;
-        }
-    });
-}
+            return Boolean(applicableObject
+                && applicableObject.hasCapability('context'));
+        };
+
+        return MoveAction;
+    }
+);
+
--- a/platform/entanglement/src/policies/MovePolicy.js
+++ b/platform/entanglement/src/policies/MovePolicy.js
@@ -20,24 +20,44 @@
 * at runtime from the About dialog for additional information.
 *****************************************************************************/

-export default function MyItemsInterceptor(openmct) {
+define([], function () {

-    openmct.objects.addGetInterceptor({
-        appliesTo: (identifier, domainObject) => {
-            return identifier.key === 'mine';
-        },
-        invoke: (identifier, object) => {
-            if (object === undefined) {
-                return {
-                    identifier,
-                    "name": "My Items",
-                    "type": "folder",
-                    "composition": [],
-                    "location": "ROOT"
-                };
-            }
+    /**
+     * Disallow moves when either the parent or the child are not
+     * modifiable by users.
+     * @constructor
+     * @implements {Policy}
+     * @memberof platform/entanglement
+     */
+    function MovePolicy() {
+    }

-            return object;
+    function parentOf(domainObject) {
+        var context = domainObject.getCapability('context');
+
+        return context && context.getParent();
+    }
+
+    function allowMutation(domainObject) {
+        var type = domainObject && domainObject.getCapability('type');
+
+        return Boolean(type && type.hasFeature('creation'));
+    }
+
+    function selectedObject(context) {
+        return context.selectedObject || context.domainObject;
+    }
+
+    MovePolicy.prototype.allow = function (action, context) {
+        var key = action.getMetadata().key;
+
+        if (key === 'move') {
+            return allowMutation(selectedObject(context))
+                && allowMutation(parentOf(selectedObject(context)));
        }
-    });
-}
+
+        return true;
+    };
+
+    return MovePolicy;
+});
--- a/platform/entanglement/src/services/MoveService.js
+++ b/platform/entanglement/src/services/MoveService.js
@@ -0,0 +1,104 @@
+/*****************************************************************************
+ * 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(
+    function () {
+        /**
+         * MoveService provides an interface for moving objects from one
+         * location to another.  It also provides a method for determining if
+         * an object can be copied to a specific location.
+         * @constructor
+         * @memberof platform/entanglement
+         * @implements {platform/entanglement.AbstractComposeService}
+         */
+        function MoveService(openmct, linkService) {
+            this.openmct = openmct;
+            this.linkService = linkService;
+        }
+
+        MoveService.prototype.validate = function (object, parentCandidate) {
+            var currentParent = object
+                .getCapability('context')
+                .getParent();
+
+            if (!parentCandidate || !parentCandidate.getId) {
+                return false;
+            }
+
+            if (parentCandidate.getId() === currentParent.getId()) {
+                return false;
+            }
+
+            if (parentCandidate.getId() === object.getId()) {
+                return false;
+            }
+
+            if (parentCandidate.getModel().composition.indexOf(object.getId()) !== -1) {
+                return false;
+            }
+
+            return this.openmct.composition.checkPolicy(
+                parentCandidate.useCapability('adapter'),
+                object.useCapability('adapter')
+            );
+        };
+
+        MoveService.prototype.perform = function (object, parentObject) {
+            function relocate(objectInNewContext) {
+                var newLocationCapability = objectInNewContext
+                        .getCapability('location'),
+                    oldLocationCapability = object
+                        .getCapability('location');
+
+                if (!newLocationCapability
+                        || !oldLocationCapability) {
+                    return;
+                }
+
+                if (oldLocationCapability.isOriginal()) {
+                    return newLocationCapability.setPrimaryLocation(
+                        newLocationCapability
+                            .getContextualLocation()
+                    );
+                }
+            }
+
+            if (!this.validate(object, parentObject)) {
+                throw new Error(
+                    "Tried to move objects without validating first."
+                );
+            }
+
+            return this.linkService
+                .perform(object, parentObject)
+                .then(relocate)
+                .then(function () {
+                    return object
+                        .getCapability('action')
+                        .perform('remove', true);
+                });
+        };
+
+        return MoveService;
+    }
+);
+
--- a/platform/entanglement/test/actions/CopyActionSpec.js
+++ b/platform/entanglement/test/actions/CopyActionSpec.js
@@ -0,0 +1,243 @@
+/*****************************************************************************
+ * 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(
+    [
+        '../../src/actions/CopyAction',
+        '../services/MockCopyService',
+        '../DomainObjectFactory'
+    ],
+    function (CopyAction, MockCopyService, domainObjectFactory) {
+
+        describe("Copy Action", function () {
+
+            var copyAction,
+                policyService,
+                locationService,
+                locationServicePromise,
+                copyService,
+                context,
+                selectedObject,
+                selectedObjectContextCapability,
+                currentParent,
+                newParent,
+                notificationService,
+                notification,
+                dialogService,
+                mockDialog,
+                mockLog,
+                abstractComposePromise,
+                domainObject = {model: {name: "mockObject"}},
+                progress = {
+                    phase: "copying",
+                    totalObjects: 10,
+                    processed: 1
+                };
+
+            beforeEach(function () {
+                policyService = jasmine.createSpyObj(
+                    'policyService',
+                    ['allow']
+                );
+                policyService.allow.and.returnValue(true);
+
+                selectedObjectContextCapability = jasmine.createSpyObj(
+                    'selectedObjectContextCapability',
+                    [
+                        'getParent'
+                    ]
+                );
+
+                selectedObject = domainObjectFactory({
+                    name: 'selectedObject',
+                    model: {
+                        name: 'selectedObject'
+                    },
+                    capabilities: {
+                        context: selectedObjectContextCapability
+                    }
+                });
+
+                currentParent = domainObjectFactory({
+                    name: 'currentParent'
+                });
+
+                selectedObjectContextCapability
+                    .getParent
+                    .and.returnValue(currentParent);
+
+                newParent = domainObjectFactory({
+                    name: 'newParent'
+                });
+
+                locationService = jasmine.createSpyObj(
+                    'locationService',
+                    [
+                        'getLocationFromUser'
+                    ]
+                );
+
+                locationServicePromise = jasmine.createSpyObj(
+                    'locationServicePromise',
+                    [
+                        'then'
+                    ]
+                );
+
+                abstractComposePromise = jasmine.createSpyObj(
+                    'abstractComposePromise',
+                    [
+                        'then'
+                    ]
+                );
+
+                abstractComposePromise.then.and.callFake(function (success, error, notify) {
+                    notify(progress);
+                    success(domainObject);
+                });
+
+                locationServicePromise.then.and.callFake(function (callback) {
+                    callback(newParent);
+
+                    return abstractComposePromise;
+                });
+
+                locationService
+                    .getLocationFromUser
+                    .and.returnValue(locationServicePromise);
+
+                dialogService = jasmine.createSpyObj('dialogService',
+                    ['showBlockingMessage']
+                );
+
+                mockDialog = jasmine.createSpyObj("dialog", ["dismiss"]);
+                dialogService.showBlockingMessage.and.returnValue(mockDialog);
+
+                notification = jasmine.createSpyObj('notification',
+                    ['dismiss', 'model']
+                );
+
+                notificationService = jasmine.createSpyObj('notificationService',
+                    ['notify', 'info']
+                );
+
+                notificationService.notify.and.returnValue(notification);
+
+                mockLog = jasmine.createSpyObj('log', ['error']);
+
+                copyService = new MockCopyService();
+            });
+
+            describe("with context from context-action", function () {
+                beforeEach(function () {
+                    context = {
+                        domainObject: selectedObject
+                    };
+
+                    copyAction = new CopyAction(
+                        mockLog,
+                        policyService,
+                        locationService,
+                        copyService,
+                        dialogService,
+                        notificationService,
+                        context
+                    );
+                });
+
+                it("initializes happily", function () {
+                    expect(copyAction).toBeDefined();
+                });
+
+                describe("when performed it", function () {
+                    beforeEach(function () {
+                        spyOn(copyAction, 'progress').and.callThrough();
+                        copyAction.perform();
+                    });
+
+                    it("prompts for location", function () {
+                        expect(locationService.getLocationFromUser)
+                            .toHaveBeenCalledWith(
+                                "Duplicate selectedObject To a Location",
+                                "Duplicate To",
+                                jasmine.any(Function),
+                                currentParent
+                            );
+                    });
+
+                    it("waits for location and handles cancellation by user", function () {
+                        expect(locationServicePromise.then)
+                            .toHaveBeenCalledWith(jasmine.any(Function), jasmine.any(Function));
+                    });
+
+                    it("copies object to selected location", function () {
+                        locationServicePromise
+                            .then
+                            .calls.mostRecent()
+                            .args[0](newParent);
+
+                        expect(copyService.perform)
+                            .toHaveBeenCalledWith(selectedObject, newParent);
+                    });
+
+                    it("notifies the user of progress", function () {
+                        expect(notificationService.info).toHaveBeenCalled();
+                    });
+
+                    it("notifies the user with name of object copied", function () {
+                        expect(notificationService.info)
+                            .toHaveBeenCalledWith("mockObject copied successfully.");
+                    });
+                });
+            });
+
+            describe("with context from drag-drop", function () {
+                beforeEach(function () {
+                    context = {
+                        selectedObject: selectedObject,
+                        domainObject: newParent
+                    };
+
+                    copyAction = new CopyAction(
+                        mockLog,
+                        policyService,
+                        locationService,
+                        copyService,
+                        dialogService,
+                        notificationService,
+                        context
+                    );
+                });
+
+                it("initializes happily", function () {
+                    expect(copyAction).toBeDefined();
+                });
+
+                it("performs copy immediately", function () {
+                    copyAction.perform();
+                    expect(copyService.perform)
+                        .toHaveBeenCalledWith(selectedObject, newParent);
+                });
+            });
+        });
+    }
+);
--- a/platform/entanglement/test/actions/MoveActionSpec.js
+++ b/platform/entanglement/test/actions/MoveActionSpec.js
@@ -0,0 +1,178 @@
+/*****************************************************************************
+ * 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(
+    [
+        '../../src/actions/MoveAction',
+        '../services/MockMoveService',
+        '../DomainObjectFactory'
+    ],
+    function (MoveAction, MockMoveService, domainObjectFactory) {
+
+        describe("Move Action", function () {
+
+            var moveAction,
+                policyService,
+                locationService,
+                locationServicePromise,
+                moveService,
+                context,
+                selectedObject,
+                selectedObjectContextCapability,
+                currentParent,
+                newParent;
+
+            beforeEach(function () {
+                policyService = jasmine.createSpyObj(
+                    'policyService',
+                    ['allow']
+                );
+                policyService.allow.and.returnValue(true);
+
+                selectedObjectContextCapability = jasmine.createSpyObj(
+                    'selectedObjectContextCapability',
+                    [
+                        'getParent'
+                    ]
+                );
+
+                selectedObject = domainObjectFactory({
+                    name: 'selectedObject',
+                    model: {
+                        name: 'selectedObject'
+                    },
+                    capabilities: {
+                        context: selectedObjectContextCapability
+                    }
+                });
+
+                currentParent = domainObjectFactory({
+                    name: 'currentParent'
+                });
+
+                selectedObjectContextCapability
+                    .getParent
+                    .and.returnValue(currentParent);
+
+                newParent = domainObjectFactory({
+                    name: 'newParent'
+                });
+
+                locationService = jasmine.createSpyObj(
+                    'locationService',
+                    [
+                        'getLocationFromUser'
+                    ]
+                );
+
+                locationServicePromise = jasmine.createSpyObj(
+                    'locationServicePromise',
+                    [
+                        'then'
+                    ]
+                );
+
+                locationService
+                    .getLocationFromUser
+                    .and.returnValue(locationServicePromise);
+
+                moveService = new MockMoveService();
+            });
+
+            describe("with context from context-action", function () {
+                beforeEach(function () {
+                    context = {
+                        domainObject: selectedObject
+                    };
+
+                    moveAction = new MoveAction(
+                        policyService,
+                        locationService,
+                        moveService,
+                        context
+                    );
+                });
+
+                it("initializes happily", function () {
+                    expect(moveAction).toBeDefined();
+                });
+
+                describe("when performed it", function () {
+                    beforeEach(function () {
+                        moveAction.perform();
+                    });
+
+                    it("prompts for location", function () {
+                        expect(locationService.getLocationFromUser)
+                            .toHaveBeenCalledWith(
+                                "Move selectedObject To a New Location",
+                                "Move To",
+                                jasmine.any(Function),
+                                currentParent
+                            );
+                    });
+
+                    it("waits for location and handles cancellation by user", function () {
+                        expect(locationServicePromise.then)
+                            .toHaveBeenCalledWith(jasmine.any(Function), jasmine.any(Function));
+                    });
+
+                    it("moves object to selected location", function () {
+                        locationServicePromise
+                            .then
+                            .calls.mostRecent()
+                            .args[0](newParent);
+
+                        expect(moveService.perform)
+                            .toHaveBeenCalledWith(selectedObject, newParent);
+                    });
+                });
+            });
+
+            describe("with context from drag-drop", function () {
+                beforeEach(function () {
+                    context = {
+                        selectedObject: selectedObject,
+                        domainObject: newParent
+                    };
+
+                    moveAction = new MoveAction(
+                        policyService,
+                        locationService,
+                        moveService,
+                        context
+                    );
+                });
+
+                it("initializes happily", function () {
+                    expect(moveAction).toBeDefined();
+                });
+
+                it("performs move immediately", function () {
+                    moveAction.perform();
+                    expect(moveService.perform)
+                        .toHaveBeenCalledWith(selectedObject, newParent);
+                });
+            });
+        });
+    }
+);
--- a/platform/entanglement/test/policies/MovePolicySpec.js
+++ b/platform/entanglement/test/policies/MovePolicySpec.js
@@ -0,0 +1,124 @@
+/*****************************************************************************
+ * 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([
+    '../../src/policies/MovePolicy',
+    '../DomainObjectFactory'
+], function (MovePolicy, domainObjectFactory) {
+
+    describe("MovePolicy", function () {
+        var testMetadata,
+            testContext,
+            mockDomainObject,
+            mockParent,
+            mockParentType,
+            mockType,
+            mockAction,
+            policy;
+
+        beforeEach(function () {
+            var mockContextCapability =
+                    jasmine.createSpyObj('context', ['getParent']);
+
+            mockType =
+                jasmine.createSpyObj('type', ['hasFeature']);
+            mockParentType =
+                jasmine.createSpyObj('parent-type', ['hasFeature']);
+
+            testMetadata = {};
+
+            mockDomainObject = domainObjectFactory({
+                capabilities: {
+                    context: mockContextCapability,
+                    type: mockType
+                }
+            });
+            mockParent = domainObjectFactory({
+                capabilities: {
+                    type: mockParentType
+                }
+            });
+
+            mockContextCapability.getParent.and.returnValue(mockParent);
+
+            mockType.hasFeature.and.callFake(function (feature) {
+                return feature === 'creation';
+            });
+            mockParentType.hasFeature.and.callFake(function (feature) {
+                return feature === 'creation';
+            });
+
+            mockAction = jasmine.createSpyObj('action', ['getMetadata']);
+            mockAction.getMetadata.and.returnValue(testMetadata);
+
+            testContext = { domainObject: mockDomainObject };
+
+            policy = new MovePolicy();
+        });
+
+        describe("for move actions", function () {
+            beforeEach(function () {
+                testMetadata.key = 'move';
+            });
+
+            describe("when an object is non-modifiable", function () {
+                beforeEach(function () {
+                    mockType.hasFeature.and.returnValue(false);
+                });
+
+                it("disallows the action", function () {
+                    expect(policy.allow(mockAction, testContext)).toBe(false);
+                });
+            });
+
+            describe("when a parent is non-modifiable", function () {
+                beforeEach(function () {
+                    mockParentType.hasFeature.and.returnValue(false);
+                });
+
+                it("disallows the action", function () {
+                    expect(policy.allow(mockAction, testContext)).toBe(false);
+                });
+            });
+
+            describe("when an object and its parent are modifiable", function () {
+                it("allows the action", function () {
+                    expect(policy.allow(mockAction, testContext)).toBe(true);
+                });
+            });
+        });
+
+        describe("for other actions", function () {
+            beforeEach(function () {
+                testMetadata.key = 'foo';
+            });
+
+            it("simply allows the action", function () {
+                expect(policy.allow(mockAction, testContext)).toBe(true);
+                mockType.hasFeature.and.returnValue(false);
+                expect(policy.allow(mockAction, testContext)).toBe(true);
+                mockParentType.hasFeature.and.returnValue(false);
+                expect(policy.allow(mockAction, testContext)).toBe(true);
+            });
+        });
+    });
+});
--- a/platform/entanglement/test/services/MockMoveService.js
+++ b/platform/entanglement/test/services/MockMoveService.js
@@ -0,0 +1,96 @@
+/*****************************************************************************
+ * 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(
+    function () {
+
+        /**
+         * MockMoveService provides the same interface as the moveService,
+         * returning promises where it would normally do so.  At it's core,
+         * it is a jasmine spy object, but it also tracks the promises it
+         * returns and provides shortcut methods for resolving those promises
+         * synchronously.
+         *
+         * Usage:
+         *
+         * ```javascript
+         * var moveService = new MockMoveService();
+         *
+         * // validate is a standard jasmine spy.
+         * moveService.validate.and.returnValue(true);
+         * var isValid = moveService.validate(object, parentCandidate);
+         * expect(isValid).toBe(true);
+         *
+         * // perform returns promises and tracks them.
+         * var whenCopied = jasmine.createSpy('whenCopied');
+         * moveService.perform(object, parentObject).then(whenCopied);
+         * expect(whenCopied).not.toHaveBeenCalled();
+         * moveService.perform.calls.mostRecent().resolve('someArg');
+         * expect(whenCopied).toHaveBeenCalledWith('someArg');
+         * ```
+         */
+        function MockMoveService() {
+            // track most recent call of a function,
+            // perform automatically returns
+            var mockMoveService = jasmine.createSpyObj(
+                'MockMoveService',
+                [
+                    'validate',
+                    'perform'
+                ]
+            );
+
+            mockMoveService.perform.and.callFake(() => {
+                var performPromise,
+                    callExtensions,
+                    spy;
+
+                performPromise = jasmine.createSpyObj(
+                    'performPromise',
+                    ['then']
+                );
+
+                callExtensions = {
+                    promise: performPromise,
+                    resolve: function (resolveWith) {
+                        performPromise.then.calls.all().forEach(function (call) {
+                            call.args[0](resolveWith);
+                        });
+                    }
+                };
+
+                spy = mockMoveService.perform;
+
+                Object.keys(callExtensions).forEach(function (key) {
+                    spy.calls.mostRecent()[key] = callExtensions[key];
+                    spy.calls.all()[spy.calls.count() - 1][key] = callExtensions[key];
+                });
+
+                return performPromise;
+            });
+
+            return mockMoveService;
+        }
+
+        return MockMoveService;
+    }
+);
--- a/platform/entanglement/test/services/MoveServiceSpec.js
+++ b/platform/entanglement/test/services/MoveServiceSpec.js
@@ -0,0 +1,260 @@
+/*****************************************************************************
+ * 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(
+    [
+        '../../src/services/MoveService',
+        '../services/MockLinkService',
+        '../DomainObjectFactory',
+        '../ControlledPromise'
+    ],
+    function (
+        MoveService,
+        MockLinkService,
+        domainObjectFactory,
+        ControlledPromise
+    ) {
+
+        xdescribe("MoveService", function () {
+
+            var moveService,
+                policyService,
+                object,
+                objectContextCapability,
+                currentParent,
+                parentCandidate,
+                linkService;
+
+            beforeEach(function () {
+                objectContextCapability = jasmine.createSpyObj(
+                    'objectContextCapability',
+                    [
+                        'getParent'
+                    ]
+                );
+
+                object = domainObjectFactory({
+                    name: 'object',
+                    id: 'a',
+                    capabilities: {
+                        context: objectContextCapability,
+                        type: { type: 'object' }
+                    }
+                });
+
+                currentParent = domainObjectFactory({
+                    name: 'currentParent',
+                    id: 'b'
+                });
+
+                objectContextCapability.getParent.and.returnValue(currentParent);
+
+                parentCandidate = domainObjectFactory({
+                    name: 'parentCandidate',
+                    model: { composition: [] },
+                    id: 'c',
+                    capabilities: {
+                        type: { type: 'parentCandidate' }
+                    }
+                });
+                policyService = jasmine.createSpyObj(
+                    'policyService',
+                    ['allow']
+                );
+                linkService = new MockLinkService();
+                policyService.allow.and.returnValue(true);
+                moveService = new MoveService(policyService, linkService);
+            });
+
+            describe("validate", function () {
+                var validate;
+
+                beforeEach(function () {
+                    validate = function () {
+                        return moveService.validate(object, parentCandidate);
+                    };
+                });
+
+                it("does not allow an invalid parent", function () {
+                    parentCandidate = undefined;
+                    expect(validate()).toBe(false);
+                    parentCandidate = {};
+                    expect(validate()).toBe(false);
+                });
+
+                it("does not allow moving to current parent", function () {
+                    parentCandidate.id = currentParent.id = 'xyz';
+                    expect(validate()).toBe(false);
+                });
+
+                it("does not allow moving to self", function () {
+                    object.id = parentCandidate.id = 'xyz';
+                    expect(validate()).toBe(false);
+                });
+
+                it("does not allow moving to the same location", function () {
+                    object.id = 'abc';
+                    parentCandidate.model.composition = ['abc'];
+                    expect(validate()).toBe(false);
+                });
+
+                describe("defers to policyService", function () {
+
+                    it("calls policy service with correct args", function () {
+                        validate();
+                        expect(policyService.allow).toHaveBeenCalledWith(
+                            "composition",
+                            parentCandidate,
+                            object
+                        );
+                    });
+
+                    it("and returns false", function () {
+                        policyService.allow.and.returnValue(false);
+                        expect(validate()).toBe(false);
+                    });
+
+                    it("and returns true", function () {
+                        policyService.allow.and.returnValue(true);
+                        expect(validate()).toBe(true);
+                    });
+                });
+            });
+
+            describe("perform", function () {
+
+                var actionCapability,
+                    locationCapability,
+                    locationPromise,
+                    newParent,
+                    moveResult;
+
+                beforeEach(function () {
+                    newParent = parentCandidate;
+
+                    actionCapability = jasmine.createSpyObj(
+                        'actionCapability',
+                        ['perform']
+                    );
+
+                    locationCapability = jasmine.createSpyObj(
+                        'locationCapability',
+                        [
+                            'isOriginal',
+                            'setPrimaryLocation',
+                            'getContextualLocation'
+                        ]
+                    );
+
+                    locationPromise = new ControlledPromise();
+                    locationCapability.setPrimaryLocation
+                        .and.returnValue(locationPromise);
+
+                    object = domainObjectFactory({
+                        name: 'object',
+                        capabilities: {
+                            action: actionCapability,
+                            location: locationCapability,
+                            context: objectContextCapability,
+                            type: { type: 'object' }
+                        }
+                    });
+                    moveResult = moveService.perform(object, newParent);
+                });
+
+                it("links object to newParent", function () {
+                    expect(linkService.perform).toHaveBeenCalledWith(
+                        object,
+                        newParent
+                    );
+                });
+
+                it("returns a promise", function () {
+                    expect(moveResult.then).toEqual(jasmine.any(Function));
+                });
+
+                it("waits for result of link", function () {
+                    expect(linkService.perform.calls.mostRecent().promise.then)
+                        .toHaveBeenCalledWith(jasmine.any(Function));
+                });
+
+                it("throws an error when performed on invalid inputs", function () {
+                    function perform() {
+                        moveService.perform(object, newParent);
+                    }
+
+                    spyOn(moveService, "validate");
+                    moveService.validate.and.returnValue(true);
+                    expect(perform).not.toThrow();
+                    moveService.validate.and.returnValue(false);
+                    expect(perform).toThrow();
+                });
+
+                describe("when moving an original", function () {
+                    beforeEach(function () {
+                        locationCapability.getContextualLocation
+                            .and.returnValue('new-location');
+                        locationCapability.isOriginal.and.returnValue(true);
+                        linkService.perform.calls.mostRecent().promise.resolve();
+                    });
+
+                    it("updates location", function () {
+                        expect(locationCapability.setPrimaryLocation)
+                            .toHaveBeenCalledWith('new-location');
+                    });
+
+                    describe("after location update", function () {
+                        beforeEach(function () {
+                            locationPromise.resolve();
+                        });
+
+                        it("removes object from parent without user warning dialog", function () {
+                            expect(actionCapability.perform)
+                                .toHaveBeenCalledWith('remove', true);
+                        });
+
+                    });
+
+                });
+
+                describe("when moving a link", function () {
+                    beforeEach(function () {
+                        locationCapability.isOriginal.and.returnValue(false);
+                        linkService.perform.calls.mostRecent().promise.resolve();
+                    });
+
+                    it("does not update location", function () {
+                        expect(locationCapability.setPrimaryLocation)
+                            .not
+                            .toHaveBeenCalled();
+                    });
+
+                    it("removes object from parent without user warning dialog", function () {
+                        expect(actionCapability.perform)
+                            .toHaveBeenCalledWith('remove', true);
+                    });
+                });
+
+            });
+        });
+    }
+);
--- a/platform/search/src/services/BareBonesSearchWorker.js
+++ b/platform/search/src/services/BareBonesSearchWorker.js
@@ -32,8 +32,7 @@
    function indexItem(id, model) {
        indexedItems.push({
            id: id,
-            name: model.name.toLowerCase(),
-            type: model.type
+            name: model.name.toLowerCase()
        });
    }

--- a/platform/search/src/services/GenericSearchProvider.js
+++ b/platform/search/src/services/GenericSearchProvider.js
@@ -125,17 +125,15 @@ define([
     * @param topic the topicService.
     */
    GenericSearchProvider.prototype.indexOnMutation = function (topic) {
-        let mutationTopic = topic('mutation');
+        var mutationTopic = topic('mutation'),
+            provider = this;

-        mutationTopic.listen(mutatedObject => {
-            let editor = mutatedObject.getCapability('editor');
+        mutationTopic.listen(function (mutatedObject) {
+            var editor = mutatedObject.getCapability('editor');
            if (!editor || !editor.inEditContext()) {
-                let mutatedObjectModel = mutatedObject.getModel();
-                this.index(
+                provider.index(
                    mutatedObject.getId(),
-                    mutatedObjectModel,
-                    mutatedObjectModel.type
-
+                    mutatedObject.getModel()
                );
            }
        });
@@ -180,15 +178,14 @@ define([
     * @param id a model id
     * @param model a model
     */
-    GenericSearchProvider.prototype.index = function (id, model, type) {
+    GenericSearchProvider.prototype.index = function (id, model) {
        var provider = this;

        if (id !== 'ROOT') {
            this.worker.postMessage({
                request: 'index',
                model: model,
-                id: id,
-                type: type
+                id: id
            });
        }

@@ -226,7 +223,7 @@ define([
            .then(function (objects) {
                delete provider.pendingIndex[idToIndex];
                if (objects[idToIndex]) {
-                    provider.index(idToIndex, objects[idToIndex].model, objects[idToIndex].model.type);
+                    provider.index(idToIndex, objects[idToIndex].model);
                }
            }, function () {
                provider
@@ -265,7 +262,6 @@ define([
                return {
                    id: hit.item.id,
                    model: hit.item.model,
-                    type: hit.item.type,
                    score: hit.matchCount
                };
            });
@@ -277,9 +273,7 @@ define([

            modelResults.hits = event.data.results.map(function (hit) {
                return {
-                    id: hit.id,
-                    name: hit.name,
-                    type: hit.type
+                    id: hit.id
                };
            });
        }
--- a/platform/search/src/services/GenericSearchWorker.js
+++ b/platform/search/src/services/GenericSearchWorker.js
@@ -41,8 +41,7 @@
        indexedItems.push({
            id: id,
            vector: vector,
-            model: model,
-            type: model.type
+            model: model
        });
    }

--- a/platform/search/src/services/SearchAggregator.js
+++ b/platform/search/src/services/SearchAggregator.js
@@ -85,8 +85,7 @@ define([
    SearchAggregator.prototype.query = function (
        inputText,
        maxResults,
-        filter,
-        indexOnly
+        filter
    ) {

        var aggregator = this,
@@ -121,24 +120,10 @@ define([
                modelResults = aggregator.applyFilter(modelResults, filter);
                modelResults = aggregator.removeDuplicates(modelResults);

-                if (indexOnly) {
-                    return Promise.resolve(modelResults);
-                }
-
                return aggregator.asObjectResults(modelResults);
            });
    };

-    SearchAggregator.prototype.queryLite = function (
-        inputText,
-        maxResults,
-        filter
-    ) {
-        const INDEX_ONLY = true;
-
-        return this.query(inputText, maxResults, filter, INDEX_ONLY);
-    };
-
    /**
     * Order model results by score descending and return them.
     */
--- a/src/MCT.js
+++ b/src/MCT.js
@@ -46,8 +46,6 @@ define([
    './api/Branding',
    './plugins/licenses/plugin',
    './plugins/remove/plugin',
-    './plugins/move/plugin',
-    './plugins/duplicate/plugin',
    'vue'
 ], function (
    EventEmitter,
@@ -75,8 +73,6 @@ define([
    BrandingAPI,
    LicensesPlugin,
    RemoveActionPlugin,
-    MoveActionPlugin,
-    DuplicateActionPlugin,
    Vue
 ) {
    /**
@@ -250,8 +246,6 @@ define([

        this.actions = new api.ActionsAPI(this);

-        this.status = new api.StatusAPI(this);
-
        this.router = new ApplicationRouter();

        this.branding = BrandingAPI.default;
@@ -267,8 +261,6 @@ define([
        this.install(LegacyIndicatorsPlugin());
        this.install(LicensesPlugin.default());
        this.install(RemoveActionPlugin.default());
-        this.install(MoveActionPlugin.default());
-        this.install(DuplicateActionPlugin.default());
        this.install(this.plugins.FolderView());
        this.install(this.plugins.Tabs());
        this.install(ImageryPlugin.default());
@@ -282,7 +274,6 @@ define([
        this.install(this.plugins.NotificationIndicator());
        this.install(this.plugins.NewFolderAction());
        this.install(this.plugins.ViewDatumAction());
-        this.install(this.plugins.ObjectInterceptors());
    }

    MCT.prototype = Object.create(EventEmitter.prototype);
--- a/src/api/actions/ActionCollection.js
+++ b/src/api/actions/ActionCollection.js
@@ -24,14 +24,13 @@ import EventEmitter from 'EventEmitter';
 import _ from 'lodash';

 class ActionCollection extends EventEmitter {
-    constructor(applicableActions, objectPath, view, openmct, skipEnvironmentObservers) {
+    constructor(applicableActions, objectPath, view, openmct) {
        super();

        this.applicableActions = applicableActions;
        this.openmct = openmct;
        this.objectPath = objectPath;
        this.view = view;
-        this.skipEnvironmentObservers = skipEnvironmentObservers;
        this.objectUnsubscribes = [];

        let debounceOptions = {
@@ -42,12 +41,10 @@ class ActionCollection extends EventEmitter {
        this._updateActions = _.debounce(this._updateActions.bind(this), 150, debounceOptions);
        this._update = _.debounce(this._update.bind(this), 150, debounceOptions);

-        if (!skipEnvironmentObservers) {
-            this._observeObjectPath();
-            this.openmct.editor.on('isEditing', this._updateActions);
-        }
-
+        this._observeObjectPath();
        this._initializeActions();
+
+        this.openmct.editor.on('isEditing', this._updateActions);
    }

    disable(actionKeys) {
@@ -87,15 +84,11 @@ class ActionCollection extends EventEmitter {
    }

    destroy() {
-        super.removeAllListeners();
+        this.objectUnsubscribes.forEach(unsubscribe => {
+            unsubscribe();
+        });

-        if (!this.skipEnvironmentObservers) {
-            this.objectUnsubscribes.forEach(unsubscribe => {
-                unsubscribe();
-            });
-
-            this.openmct.editor.off('isEditing', this._updateActions);
-        }
+        this.openmct.editor.off('isEditing', this._updateActions);

        this.emit('destroy', this.view);
    }
@@ -130,10 +123,6 @@ class ActionCollection extends EventEmitter {
        return statusBarActions;
    }

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

    get(objectPath, view) {
-        if (view) {
+        let viewContext = view && view.getViewContext && view.getViewContext() || {};

-            return this._getCachedActionCollection(objectPath, view) || this._newActionCollection(objectPath, view, true);
+        if (view && !viewContext.skipCache) {
+            let cachedActionCollection = this._actionCollections.get(view);
+
+            if (cachedActionCollection) {
+                return cachedActionCollection;
+            } else {
+                let applicableActions = this._applicableActions(objectPath, view);
+                let actionCollection = new ActionCollection(applicableActions, objectPath, view, this._openmct);
+
+                this._actionCollections.set(view, actionCollection);
+                actionCollection.on('destroy', this._updateCachedActionCollections);
+
+                return actionCollection;
+            }
        } else {
+            let applicableActions = this._applicableActions(objectPath, view);

-            return this._newActionCollection(objectPath, view, true);
+            Object.keys(applicableActions).forEach(key => {
+                let action = applicableActions[key];
+
+                action.callBack = () => {
+                    return action.invoke(objectPath, view);
+                };
+            });
+
+            return applicableActions;
        }
    }

@@ -57,27 +79,6 @@ class ActionsAPI extends EventEmitter {
        this._groupOrder = groupArray;
    }

-    _get(objectPath, view) {
-        let actionCollection = this._newActionCollection(objectPath, view);
-
-        this._actionCollections.set(view, actionCollection);
-        actionCollection.on('destroy', this._updateCachedActionCollections);
-
-        return actionCollection;
-    }
-
-    _getCachedActionCollection(objectPath, view) {
-        let cachedActionCollection = this._actionCollections.get(view);
-
-        return cachedActionCollection;
-    }
-
-    _newActionCollection(objectPath, view, skipEnvironmentObservers) {
-        let applicableActions = this._applicableActions(objectPath, view);
-
-        return new ActionCollection(applicableActions, objectPath, view, this._openmct, skipEnvironmentObservers);
-    }
-
    _updateCachedActionCollections(key) {
        if (this._actionCollections.has(key)) {
            let actionCollection = this._actionCollections.get(key);
--- a/src/api/actions/ActionsAPISpec.js
+++ b/src/api/actions/ActionsAPISpec.js
@@ -21,54 +21,40 @@
 *****************************************************************************/

 import ActionsAPI from './ActionsAPI';
+import ActionsCollection from './ActionCollection';
 import { createOpenMct, resetApplicationState } from '../../utils/testing';
-import ActionCollection from './ActionCollection';

 describe('The Actions API', () => {
    let openmct;
    let actionsAPI;
    let mockAction;
+    let invoked;
    let mockObjectPath;
-    let mockObjectPathAction;
    let mockViewContext1;
+    let mockViewContext2;

    beforeEach(() => {
        openmct = createOpenMct();
        actionsAPI = new ActionsAPI(openmct);
-        mockObjectPathAction = {
-            name: 'Test Action Object Path',
-            key: 'test-action-object-path',
-            cssClass: 'test-action-object-path',
-            description: 'This is a test action for object path',
+        mockAction = {
+            name: 'Test Action',
+            key: 'test-action',
+            cssClass: 'test-action',
+            description: 'This is a test action',
            group: 'action',
            priority: 9,
-            appliesTo: (objectPath) => {
-                if (objectPath.length) {
+            appliesTo: (objectPath, view = {}) => {
+                if (view.getViewContext) {
+                    let viewContext = view.getViewContext();
+                    return viewContext.onlyAppliesToTestCase;
+                } else if (objectPath.length) {
                    return objectPath[0].type === 'fake-folder';
                }

                return false;
            },
            invoke: () => {
-            }
-        };
-        mockAction = {
-            name: 'Test Action View',
-            key: 'test-action-view',
-            cssClass: 'test-action-view',
-            description: 'This is a test action for view',
-            group: 'action',
-            priority: 9,
-            appliesTo: (objectPath, view = {}) => {
-                if (view.getViewContext) {
-                    let viewContext = view.getViewContext();
-
-                    return viewContext.onlyAppliesToTestCase;
-                }
-
-                return false;
-            },
-            invoke: () => {
+                invoked = true;
            }
        };
        mockObjectPath = [
@@ -91,6 +77,14 @@ describe('The Actions API', () => {
        ];
        mockViewContext1 = {
            getViewContext: () => {
+                return {
+                    onlyAppliesToTestCase: true,
+                    skipCache: true
+                };
+            }
+        };
+        mockViewContext2 = {
+            getViewContext:() => {
                return {
                    onlyAppliesToTestCase: true
                };
@@ -105,9 +99,8 @@ describe('The Actions API', () => {
    describe("register method", () => {
        it("adds action to ActionsAPI", () => {
            actionsAPI.register(mockAction);
-
-            let actionCollection = actionsAPI.get(mockObjectPath, mockViewContext1);
-            let action = actionCollection.getActionsObject()[mockAction.key];
+            
+            let action = actionsAPI.get(mockObjectPath, mockViewContext1)[mockAction.key];

            expect(action.key).toEqual(mockAction.key);
            expect(action.name).toEqual(mockAction.name);
@@ -117,34 +110,17 @@ describe('The Actions API', () => {
    describe("get method", () => {
        beforeEach(() => {
            actionsAPI.register(mockAction);
-            actionsAPI.register(mockObjectPathAction);
        });

-        it("returns an ActionCollection when invoked with an objectPath only", () => {
-            let actionCollection = actionsAPI.get(mockObjectPath);
-            let instanceOfActionCollection = actionCollection instanceof ActionCollection;
+        it("returns an object with relevant actions when invoked with objectPath only", () => {
+            let action = actionsAPI.get(mockObjectPath, mockViewContext1)[mockAction.key];

-            expect(instanceOfActionCollection).toBeTrue();
+            expect(action.key).toEqual(mockAction.key);
+            expect(action.name).toEqual(mockAction.name);
        });

-        it("returns an ActionCollection when invoked with an objectPath and view", () => {
-            let actionCollection = actionsAPI.get(mockObjectPath, mockViewContext1);
-            let instanceOfActionCollection = actionCollection instanceof ActionCollection;
-
-            expect(instanceOfActionCollection).toBeTrue();
-        });
-
-        it("returns relevant actions when invoked with objectPath only", () => {
-            let actionCollection = actionsAPI.get(mockObjectPath);
-            let action = actionCollection.getActionsObject()[mockObjectPathAction.key];
-
-            expect(action.key).toEqual(mockObjectPathAction.key);
-            expect(action.name).toEqual(mockObjectPathAction.name);
-        });
-
-        it("returns relevant actions when invoked with objectPath and view", () => {
-            let actionCollection = actionsAPI.get(mockObjectPath, mockViewContext1);
-            let action = actionCollection.getActionsObject()[mockAction.key];
+        it("returns an object with relevant actions when invoked with viewContext and skipCache", () => {
+            let action = actionsAPI.get(mockObjectPath, mockViewContext1)[mockAction.key];

            expect(action.key).toEqual(mockAction.key);
            expect(action.name).toEqual(mockAction.name);
--- a/src/api/api.js
+++ b/src/api/api.js
@@ -30,8 +30,8 @@ define([
    './notifications/NotificationAPI',
    './Editor',
    './menu/MenuAPI',
-    './actions/ActionsAPI',
-    './status/StatusAPI'
+    './actions/ActionsAPI'
+
 ], function (
    TimeAPI,
    ObjectAPI,
@@ -42,8 +42,7 @@ define([
    NotificationAPI,
    EditorAPI,
    MenuAPI,
-    ActionsAPI,
-    StatusAPI
+    ActionsAPI
 ) {
    return {
        TimeAPI: TimeAPI,
@@ -55,7 +54,6 @@ define([
        NotificationAPI: NotificationAPI.default,
        EditorAPI: EditorAPI,
        MenuAPI: MenuAPI.default,
-        ActionsAPI: ActionsAPI.default,
-        StatusAPI: StatusAPI.default
+        ActionsAPI: ActionsAPI.default
    };
 });
--- a/src/api/objects/InterceptorRegistry.js
+++ b/src/api/objects/InterceptorRegistry.js
@@ -1,66 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-export default class InterceptorRegistry {
-    /**
-     * A InterceptorRegistry maintains the definitions for different interceptors that may be invoked on domain objects.
-     * @interface InterceptorRegistry
-     * @memberof module:openmct
-     */
-    constructor() {
-        this.interceptors = [];
-    }
-
-    /**
-     * @interface InterceptorDef
-     * @property {function} appliesTo function that determines if this interceptor should be called for the given identifier/object
-     * @property {function} invoke function that transforms the provided domain object and returns the transformed domain object
-     * @property {function} priority the priority for this interceptor. A higher number returned has more weight than a lower number
-     * @memberof module:openmct InterceptorRegistry#
-     */
-
-    /**
-     * Register a new object interceptor.
-     *
-     * @param {module:openmct.InterceptorDef} interceptorDef the interceptor to add
-     * @method addInterceptor
-     * @memberof module:openmct.InterceptorRegistry#
-     */
-    addInterceptor(interceptorDef) {
-        //TODO: sort by priority
-        this.interceptors.push(interceptorDef);
-    }
-
-    /**
-     * Retrieve all interceptors applicable to a domain object.
-     * @method getInterceptors
-     * @returns [module:openmct.InterceptorDef] the registered interceptors for this identifier/object
-     * @memberof module:openmct.InterceptorRegistry#
-     */
-    getInterceptors(identifier, object) {
-        return this.interceptors.filter(interceptor => {
-            return typeof interceptor.appliesTo === 'function'
-                && interceptor.appliesTo(identifier, object);
-        });
-    }
-
-}
-
--- a/src/api/objects/InterceptorRegistrySpec.js
+++ b/src/api/objects/InterceptorRegistrySpec.js
--- a/src/api/objects/ObjectAPI.js
+++ b/src/api/objects/ObjectAPI.js
@@ -26,7 +26,6 @@ define([
    './MutableObject',
    './RootRegistry',
    './RootObjectProvider',
-    './InterceptorRegistry',
    'EventEmitter'
 ], function (
    _,
@@ -34,7 +33,6 @@ define([
    MutableObject,
    RootRegistry,
    RootObjectProvider,
-    InterceptorRegistry,
    EventEmitter
 ) {

@@ -50,7 +48,6 @@ define([
        this.rootRegistry = new RootRegistry();
        this.rootProvider = new RootObjectProvider.default(this.rootRegistry);
        this.cache = {};
-        this.interceptorRegistry = new InterceptorRegistry.default();
    }

    /**
@@ -180,10 +177,6 @@ define([

        return objectPromise.then(result => {
            delete this.cache[keystring];
-            const interceptors = this.listGetInterceptors(identifier, result);
-            interceptors.forEach(interceptor => {
-                result = interceptor.invoke(identifier, result);
-            });

            return result;
        });
@@ -319,27 +312,6 @@ define([
        });
    };

-    /**
-     * 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.
     *
--- a/src/api/objects/ObjectAPISpec.js
+++ b/src/api/objects/ObjectAPISpec.js
@@ -63,51 +63,12 @@ describe("The Object API", () => {
    describe("The get function", () => {
        describe("when a provider is available", () => {
            let mockProvider;
-            let mockInterceptor;
-            let anotherMockInterceptor;
-            let notApplicableMockInterceptor;
            beforeEach(() => {
                mockProvider = jasmine.createSpyObj("mock provider", [
                    "get"
                ]);
                mockProvider.get.and.returnValue(Promise.resolve(mockDomainObject));
-
-                mockInterceptor = jasmine.createSpyObj("mock interceptor", [
-                    "appliesTo",
-                    "invoke"
-                ]);
-                mockInterceptor.appliesTo.and.returnValue(true);
-                mockInterceptor.invoke.and.callFake((identifier, object) => {
-                    return Object.assign({
-                        changed: true
-                    }, object);
-                });
-
-                anotherMockInterceptor = jasmine.createSpyObj("another mock interceptor", [
-                    "appliesTo",
-                    "invoke"
-                ]);
-                anotherMockInterceptor.appliesTo.and.returnValue(true);
-                anotherMockInterceptor.invoke.and.callFake((identifier, object) => {
-                    return Object.assign({
-                        alsoChanged: true
-                    }, object);
-                });
-
-                notApplicableMockInterceptor = jasmine.createSpyObj("not applicable mock interceptor", [
-                    "appliesTo",
-                    "invoke"
-                ]);
-                notApplicableMockInterceptor.appliesTo.and.returnValue(false);
-                notApplicableMockInterceptor.invoke.and.callFake((identifier, object) => {
-                    return Object.assign({
-                        shouldNotBeChanged: true
-                    }, object);
-                });
                objectAPI.addProvider(TEST_NAMESPACE, mockProvider);
-                objectAPI.addGetInterceptor(mockInterceptor);
-                objectAPI.addGetInterceptor(anotherMockInterceptor);
-                objectAPI.addGetInterceptor(notApplicableMockInterceptor);
            });

            it("Caches multiple requests for the same object", () => {
@@ -117,15 +78,6 @@ describe("The Object API", () => {
                objectAPI.get(mockDomainObject.identifier);
                expect(mockProvider.get.calls.count()).toBe(1);
            });
-
-            it("applies any applicable interceptors", () => {
-                expect(mockDomainObject.changed).toBeUndefined();
-                objectAPI.get(mockDomainObject.identifier).then((object) => {
-                    expect(object.changed).toBeTrue();
-                    expect(object.alsoChanged).toBeTrue();
-                    expect(object.shouldNotBeChanged).toBeUndefined();
-                });
-            });
        });
    });
 });
--- a/src/api/status/StatusAPI.js
+++ b/src/api/status/StatusAPI.js
@@ -1,67 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-
-import EventEmitter from 'EventEmitter';
-
-export default class StatusAPI extends EventEmitter {
-    constructor(openmct) {
-        super();
-
-        this._openmct = openmct;
-        this._statusCache = {};
-
-        this.get = this.get.bind(this);
-        this.set = this.set.bind(this);
-        this.observe = this.observe.bind(this);
-    }
-
-    get(identifier) {
-        let keyString = this._openmct.objects.makeKeyString(identifier);
-
-        return this._statusCache[keyString];
-    }
-
-    set(identifier, value) {
-        let keyString = this._openmct.objects.makeKeyString(identifier);
-
-        this._statusCache[keyString] = value;
-        this.emit(keyString, value);
-    }
-
-    delete(identifier) {
-        let keyString = this._openmct.objects.makeKeyString(identifier);
-
-        this._statusCache[keyString] = undefined;
-        this.emit(keyString, undefined);
-        delete this._statusCache[keyString];
-    }
-
-    observe(identifier, callback) {
-        let key = this._openmct.objects.makeKeyString(identifier);
-
-        this.on(key, callback);
-
-        return () => {
-            this.off(key, callback);
-        };
-    }
-}
--- a/src/api/status/StatusAPISpec.js
+++ b/src/api/status/StatusAPISpec.js
@@ -1,85 +0,0 @@
-import StatusAPI from './StatusAPI.js';
-import { createOpenMct, resetApplicationState } from '../../utils/testing';
-
-describe("The Status API", () => {
-    let statusAPI;
-    let openmct;
-    let identifier;
-    let status;
-    let status2;
-    let callback;
-
-    beforeEach(() => {
-        openmct = createOpenMct();
-        statusAPI = new StatusAPI(openmct);
-        identifier = {
-            namespace: "test-namespace",
-            key: "test-key"
-        };
-        status = "test-status";
-        status2 = 'test-status-deux';
-        callback = jasmine.createSpy('callback', (statusUpdate) => statusUpdate);
-    });
-
-    afterEach(() => {
-        resetApplicationState(openmct);
-    });
-
-    describe("set function", () => {
-        it("sets status for identifier", () => {
-            statusAPI.set(identifier, status);
-
-            let resultingStatus = statusAPI.get(identifier);
-
-            expect(resultingStatus).toEqual(status);
-        });
-    });
-
-    describe("get function", () => {
-        it("returns status for identifier", () => {
-            statusAPI.set(identifier, status2);
-
-            let resultingStatus = statusAPI.get(identifier);
-
-            expect(resultingStatus).toEqual(status2);
-        });
-    });
-
-    describe("delete function", () => {
-        it("deletes status for identifier", () => {
-            statusAPI.set(identifier, status);
-
-            let resultingStatus = statusAPI.get(identifier);
-            expect(resultingStatus).toEqual(status);
-
-            statusAPI.delete(identifier);
-            resultingStatus = statusAPI.get(identifier);
-
-            expect(resultingStatus).toBeUndefined();
-        });
-    });
-
-    describe("observe function", () => {
-
-        it("allows callbacks to be attached to status set and delete events", () => {
-            let unsubscribe = statusAPI.observe(identifier, callback);
-            statusAPI.set(identifier, status);
-
-            expect(callback).toHaveBeenCalledWith(status);
-
-            statusAPI.delete(identifier);
-
-            expect(callback).toHaveBeenCalledWith(undefined);
-            unsubscribe();
-        });
-
-        it("returns a unsubscribe function", () => {
-            let unsubscribe = statusAPI.observe(identifier, callback);
-            unsubscribe();
-
-            statusAPI.set(identifier, status);
-
-            expect(callback).toHaveBeenCalledTimes(0);
-        });
-    });
-});
--- a/src/api/telemetry/TelemetryAPI.js
+++ b/src/api/telemetry/TelemetryAPI.js
@@ -20,17 +20,13 @@
 * at runtime from the About dialog for additional information.
 *****************************************************************************/

-const { TelemetryCollection } = require("./TelemetryCollection");
-
 define([
-    '../../plugins/displayLayout/CustomStringFormatter',
    './TelemetryMetadataManager',
    './TelemetryValueFormatter',
    './DefaultMetadataProvider',
    'objectUtils',
    'lodash'
 ], function (
-    CustomStringFormatter,
    TelemetryMetadataManager,
    TelemetryValueFormatter,
    DefaultMetadataProvider,
@@ -146,17 +142,6 @@ define([
        this.valueFormatterCache = new WeakMap();
    }

-    /**
-     * Return Custom String Formatter
-     *
-     * @param {Object} valueMetadata valueMetadata for given telemetry object
-     * @param {string} format custom formatter string (eg: %.4f, &lts etc.)
-     * @returns {CustomStringFormatter}
-     */
-    TelemetryAPI.prototype.customStringFormatter = function (valueMetadata, format) {
-        return new CustomStringFormatter.default(this.openmct, valueMetadata, format);
-    };
-
    /**
     * Return true if the given domainObject is a telemetry object.  A telemetry
     * object is any object which has telemetry metadata-- regardless of whether
@@ -275,48 +260,6 @@ define([
        }
    };

-    /**
-     * Request telemetry collection for a domain object.
-     * The `options` argument allows you to specify filters
-     * (start, end, etc.), sort order, and strategies for retrieving
-     * telemetry (aggregation, latest available, etc.).
-     *
-     * @method request
-     * @memberof module:openmct.TelemetryAPI~TelemetryProvider#
-     * @param {module:openmct.DomainObject} domainObject the object
-     *        which has associated telemetry
-     * @param {module:openmct.TelemetryAPI~TelemetryRequest} options
-     *        options for this historical request
-     * @returns {Promise.<object[]>} a promise for an array of
-     *          telemetry data
-     */
-    TelemetryAPI.prototype.requestTelemetryCollection = function (domainObject) {
-        if (arguments.length === 1) {
-            arguments.length = 2;
-            arguments[1] = {};
-        }
-
-        // historical setup
-        this.standardizeRequestOptions(arguments[1]);
-        const historicalProvider = this.findRequestProvider(domainObject, arguments);
-
-        // subscription setup
-        const subscriptionProvider = this.findSubscriptionProvider(domainObject);
-
-        // check for no providers
-        if (!historicalProvider && !subscriptionProvider) {
-            return Promise.reject('No providers found');
-        }
-
-        let telemetryCollectionOptions = {
-            historicalProvider,
-            subscriptionProvider,
-            arguments: arguments
-        };
-
-        return Promise.resolve(new TelemetryCollection(this.openmct, domainObject, telemetryCollectionOptions));
-    };
-
    /**
     * Request historical telemetry for a domain object.
     * The `options` argument allows you to specify filters
@@ -457,17 +400,6 @@ define([
        return _.sortBy(options, sortKeys);
    };

-    /**
-     * @private
-     */
-    TelemetryAPI.prototype.getFormatService = function () {
-        if (!this.formatService) {
-            this.formatService = this.openmct.$injector.get('formatService');
-        }
-
-        return this.formatService;
-    };
-
    /**
     * Get a value formatter for a given valueMetadata.
     *
@@ -475,27 +407,19 @@ define([
     */
    TelemetryAPI.prototype.getValueFormatter = function (valueMetadata) {
        if (!this.valueFormatterCache.has(valueMetadata)) {
+            if (!this.formatService) {
+                this.formatService = this.openmct.$injector.get('formatService');
+            }
+
            this.valueFormatterCache.set(
                valueMetadata,
-                new TelemetryValueFormatter(valueMetadata, this.getFormatService())
+                new TelemetryValueFormatter(valueMetadata, this.formatService)
            );
        }

        return this.valueFormatterCache.get(valueMetadata);
    };

-    /**
-     * Get a value formatter for a given key.
-     * @param {string} key
-     *
-     * @returns {Format}
-     */
-    TelemetryAPI.prototype.getFormatter = function (key) {
-        const formatMap = this.getFormatService().formatMap;
-
-        return formatMap[key];
-    };
-
    /**
     * Get a format map of all value formatters for a given piece of telemetry
     * metadata.
--- a/src/api/telemetry/TelemetryCollection.js
+++ b/src/api/telemetry/TelemetryCollection.js
@@ -1,315 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-
-// import _ from 'lodash';
-import TelemetrySubscriptionService from './TelemetrySubscriptionService';
-
-function bindUs() {
-    return [
-        'trackHistoricalTelemetry',
-        'trackSubscriptionTelemetry',
-        'addPage',
-        'processNewTelemetry',
-        'hasMorePages',
-        'nextPage',
-        'bounds',
-        'timeSystem',
-        'on',
-        'off',
-        'emit',
-        'subscribeToBounds',
-        'unsubscribeFromBounds',
-        'subscribeToTimeSystem',
-        'unsubscribeFromTimeSystem',
-        'destroy'
-    ];
-}
-
-export class TelemetryCollection {
-
-    constructor(openmct, domainObject, options) {
-        bindUs().forEach(method => this[method] = this[method].bind(this));
-
-        this.openmct = openmct;
-        this.domainObject = domainObject;
-        this.boundedTelemetry = [];
-        this.futureBuffer = [];
-
-        this.parseTime = undefined;
-        this.timeSystem(openmct.time.timeSystem());
-        this.lastBounds = openmct.time.bounds();
-
-        this.historicalProvider = options.historicalProvider;
-        this.subscriptionProvider = options.subscriptionProvider;
-
-        this.arguments = options.arguments;
-
-        this.listeners = {
-            add: [],
-            remove: []
-        };
-
-        this.trackHistoricalTelemetry();
-        this.trackSubscriptionTelemetry();
-
-        this.subscribeToBounds();
-        this.subscribeToTimeSystem();
-    }
-
-    // should we wait to track history until an 'add' listener is added?
-    async trackHistoricalTelemetry() {
-        if (!this.historicalProvider) {
-            return;
-        }
-
-        // remove for reset
-        if (this.boundedTelemetry.length !== 0) {
-            this.emit('remove', this.boundedTelemetry);
-            this.boundedTelemetry = [];
-        }
-
-        let historicalData = await this.historicalProvider.request.apply(this.domainObject, this.arguments).catch((rejected) => {
-            this.openmct.notifications.error('Error requesting telemetry data, see console for details');
-            console.error(rejected);
-
-            return Promise.reject(rejected);
-        });
-
-        // make sure it wasn't rejected
-        if (Array.isArray(historicalData)) {
-            // reset on requests, should only happen on initial load,
-            // bounds manually changed and time system changes
-            this.boundedTelemetry = historicalData;
-            this.emit('add', [...this.boundedTelemetry]);
-        }
-    }
-
-    trackSubscriptionTelemetry() {
-        if (!this.subscriptionProvider) {
-            return;
-        }
-
-        this.subscriptionService = new TelemetrySubscriptionService(this.openmct);
-        this.unsubscribe = this.subscriptionService.subscribe(
-            this.domainObject,
-            this.processNewTelemetry,
-            this.subscriptionProvider,
-            this.arguments
-        );
-    }
-
-    // utilized by telemetry provider to add more data
-    addPage(telemetryData) {
-        this.processNewTelemetry(telemetryData);
-    }
-
-    // used to sort any new telemetry (add/page, historical, subscription)
-    processNewTelemetry(telemetryData) {
-
-        let data = Array.isArray(telemetryData) ? telemetryData : [telemetryData];
-        let parsedValue;
-        let beforeStartOfBounds;
-        let afterEndOfBounds;
-        let added = [];
-
-        for (let datum of data) {
-            parsedValue = this.parseTime(datum);
-            beforeStartOfBounds = parsedValue < this.lastBounds.start;
-            afterEndOfBounds = parsedValue > this.lastBounds.end;
-
-            if (!afterEndOfBounds && !beforeStartOfBounds) {
-                if (!this.boundedTelemetry.includes(datum)) {
-                    this.boundedTelemetry.push(datum);
-                    added.push(datum);
-                }
-            } else if (afterEndOfBounds) {
-                this.futureBuffer.push(datum);
-            }
-        }
-
-        if (added.length) {
-            this.emit('add', added);
-        }
-    }
-
-    // returns a boolean if there is more telemetry within the time bounds 
-    // if the provider supports it
-    hasMorePages() {
-        return this.historicalProvider
-            && this.historicalProvider.supportsPaging()
-            && this.historicalProvider.hasMorePages(this);
-    }
-
-    // will return the next "page" of telemetry if the provider supports it
-    nextPage() {
-        if (!this.historicalProvider || !this.historicalProvider.supportsPaging()) {
-            throw new Error('Provider does not support paging');
-        }
-
-        this.historicalProvider.nextPage(this.arguments, this);
-    }
-
-    // when user changes bounds, or when bounds increment from a tick
-    bounds(bounds, isTick) {
-
-        this.lastBounds = bounds;
-
-        if (isTick) {
-            // need to check futureBuffer and need to check
-            // if anything has fallen out of bounds
-        } else {
-            // TODO: also reset right?
-            // need to reset and request history again
-            // no need to mess with subscription
-        }
-
-        let startChanged = this.lastBounds.start !== bounds.start;
-        let endChanged = this.lastBounds.end !== bounds.end;
-
-        let startIndex = 0;
-        let endIndex = 0;
-
-        let discarded = [];
-        let added = [];
-        let testValue = {
-            datum: {}
-        };
-
-        this.lastBounds = bounds;
-
-        if (startChanged) {
-            testValue.datum[this.sortOptions.key] = bounds.start;
-            // Calculate the new index of the first item within the bounds
-            startIndex = this.sortedIndex(this.rows, testValue);
-            discarded = this.rows.splice(0, startIndex);
-        }
-
-        if (endChanged) {
-            testValue.datum[this.sortOptions.key] = bounds.end;
-            // Calculate the new index of the last item in bounds
-            endIndex = this.sortedLastIndex(this.futureBuffer.rows, testValue);
-            added = this.futureBuffer.rows.splice(0, endIndex);
-            added.forEach((datum) => this.rows.push(datum));
-        }
-
-        if (discarded.length > 0) {
-            /**
-             * A `discarded` event is emitted when telemetry data fall out of
-             * bounds due to a bounds change event
-             * @type {object[]} discarded the telemetry data
-             * discarded as a result of the bounds change
-             */
-            this.emit('remove', discarded);
-        }
-
-        if (added.length > 0) {
-            /**
-             * An `added` event is emitted when a bounds change results in
-             * received telemetry falling within the new bounds.
-             * @type {object[]} added the telemetry data that is now within bounds
-             */
-            this.emit('add', added);
-        }
-    }
-
-    timeSystem(timeSystem) {
-        let timeKey = timeSystem.key;
-        let formatter = this.openmct.telemetry.getValueFormatter({
-            key: timeKey,
-            source: timeKey,
-            format: timeKey
-        });
-
-        this.parseTime = formatter.parse;
-
-        // TODO: Reset right?
-    }
-
-    on(event, callback, context) {
-        if (!this.listeners[event]) {
-            throw new Error('Event not supported by Telemetry Collections: ' + event);
-        }
-
-        if (this.listeners[event].includes(callback)) {
-            throw new Error('Tried to add a listener that is already registered');
-        }
-
-        this.listeners[event].push({
-            callback: callback,
-            context: context
-        });
-    }
-
-    // Unregister TelemetryCollection events.
-    off(event, callback) {
-        if (!this.listeners[event]) {
-            throw new Error('Event not supported by Telemetry Collections: ' + event);
-        }
-
-        if (!this.listeners[event].includes(callback)) {
-            throw new Error('Tried to remove a listener that does not exist');
-        }
-
-        this.listeners[event].remove(callback);
-    }
-
-    emit(event, payload) {
-        if (!this.listeners[event].length) {
-            return;
-        }
-
-        payload = [...payload];
-
-        this.listeners[event].forEach((listener) => {
-            if (listener.context) {
-                listener.callback.apply(listener.context, payload);
-            } else {
-                listener.callback(payload);
-            }
-        });
-    }
-
-    subscribeToBounds() {
-        this.openmct.time.on('bounds', this.bounds);
-    }
-
-    unsubscribeFromBounds() {
-        this.openmct.time.off('bounds', this.bounds);
-    }
-
-    subscribeToTimeSystem() {
-        this.openmct.time.on('timeSystem', this.timeSystem);
-    }
-
-    unsubscribeFromTimeSystem() {
-        this.openmct.time.off('bounds', this.timeSystem);
-    }
-
-    destroy() {
-        this.unsubscribeFromBounds();
-        this.unsubscribeFromTimeSystem();
-        if (this.unsubscribe) {
-            this.unsubscribe();
-        }
-    }
-
-}
--- a/src/api/telemetry/TelemetrySubscriptionService.js
+++ b/src/api/telemetry/TelemetrySubscriptionService.js
@@ -1,72 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-
-import objectUtils from 'objectUtils';
-class TelemetrySubscriptionService {
-    constructor(openmct) {
-        if (!TelemetrySubscriptionService.instance) {
-            this.openmct = openmct;
-            this.subscriptionCache = {};
-
-            TelemetrySubscriptionService.instance = this;
-        }
-
-        return TelemetrySubscriptionService.instance; // eslint-disable-line no-constructor-return
-    }
-
-    subscribe(domainObject, callback, provider, options) {
-        const keyString = objectUtils.makeKeyString(domainObject.identifier);
-        let subscriber = this.subscriptionCache[keyString];
-
-        if (!subscriber) {
-            subscriber = this.subscriptionCache[keyString] = {
-                callbacks: [callback]
-            };
-
-            subscriber.unsubscribe = provider
-                .subscribe(domainObject, function (value) {
-                    subscriber.callbacks.forEach(function (cb) {
-                        cb(value);
-                    });
-                }, options);
-        } else {
-            subscriber.callbacks.push(callback);
-        }
-
-        return () => {
-            subscriber.callbacks = subscriber.callbacks.filter((cb) => {
-                return cb !== callback;
-            });
-            if (subscriber.callbacks.length === 0) {
-                subscriber.unsubscribe();
-                delete this.subscriptionCache[keyString];
-            }
-        };
-    }
-
-}
-
-function instance(openmct) {
-    return new TelemetrySubscriptionService(openmct);
-}
-
-export default instance;
--- a/src/plugins/LADTable/components/LADRow.vue
+++ b/src/plugins/LADTable/components/LADRow.vue
@@ -44,7 +44,6 @@
 <script>

 const CONTEXT_MENU_ACTIONS = [
-    'viewDatumAction',
    'viewHistoricalData',
    'remove'
 ];
@@ -130,7 +129,6 @@ export default {
            let limit;

            if (this.shouldUpdate(newTimestamp)) {
-                this.datum = datum;
                this.timestamp = newTimestamp;
                this.value = this.formats[this.valueKey].format(datum);
                limit = this.limitEvaluator.evaluate(datum, this.valueMetadata);
@@ -177,22 +175,8 @@ export default {
            this.resetValues();
            this.timestampKey = timeSystem.key;
        },
-        getView() {
-            return {
-                getViewContext: () => {
-                    return {
-                        viewHistoricalData: true,
-                        viewDatumAction: true,
-                        getDatum: () => {
-                            return this.datum;
-                        }
-                    };
-                }
-            };
-        },
        showContextMenu(event) {
-            let actionCollection = this.openmct.actions.get(this.currentObjectPath, this.getView());
-            let allActions = actionCollection.getActionsObject();
+            let allActions = this.openmct.actions.get(this.currentObjectPath, {}, {viewHistoricalData: true});
            let applicableActions = CONTEXT_MENU_ACTIONS.map(key => allActions[key]);

            this.openmct.menus.showMenu(event.x, event.y, applicableActions);
--- a/src/plugins/autoflow/AutoflowTabularPluginSpec.js
+++ b/src/plugins/autoflow/AutoflowTabularPluginSpec.js
@@ -19,352 +19,342 @@
 * this source code distribution or the Licensing information page available
 * at runtime from the About dialog for additional information.
 *****************************************************************************/
-import AutoflowTabularPlugin from './AutoflowTabularPlugin';
-import AutoflowTabularConstants from './AutoflowTabularConstants';
-import $ from 'zepto';
-import DOMObserver from './dom-observer';
-import {
-    createOpenMct,
-    resetApplicationState,
-    spyOnBuiltins
-} from 'utils/testing';

-describe("AutoflowTabularPlugin", () => {
-    let testType;
-    let testObject;
-    let mockmct;
+define([
+    './AutoflowTabularPlugin',
+    './AutoflowTabularConstants',
+    '../../MCT',
+    'zepto',
+    './dom-observer'
+], function (AutoflowTabularPlugin, AutoflowTabularConstants, MCT, $, DOMObserver) {
+    describe("AutoflowTabularPlugin", function () {
+        let testType;
+        let testObject;
+        let mockmct;

-    beforeEach(() => {
-        testType = "some-type";
-        testObject = { type: testType };
-        mockmct = createOpenMct();
-        spyOn(mockmct.composition, 'get');
-        spyOn(mockmct.objectViews, 'addProvider');
-        spyOn(mockmct.telemetry, 'getMetadata');
-        spyOn(mockmct.telemetry, 'getValueFormatter');
-        spyOn(mockmct.telemetry, 'limitEvaluator');
-        spyOn(mockmct.telemetry, 'request');
-        spyOn(mockmct.telemetry, 'subscribe');
+        beforeEach(function () {
+            testType = "some-type";
+            testObject = { type: testType };
+            mockmct = new MCT();
+            spyOn(mockmct.composition, 'get');
+            spyOn(mockmct.objectViews, 'addProvider');
+            spyOn(mockmct.telemetry, 'getMetadata');
+            spyOn(mockmct.telemetry, 'getValueFormatter');
+            spyOn(mockmct.telemetry, 'limitEvaluator');
+            spyOn(mockmct.telemetry, 'request');
+            spyOn(mockmct.telemetry, 'subscribe');

-        const plugin = new AutoflowTabularPlugin({ type: testType });
-        plugin(mockmct);
-    });
-
-    afterEach(() => {
-        resetApplicationState(mockmct);
-    });
-
-    it("installs a view provider", () => {
-        expect(mockmct.objectViews.addProvider).toHaveBeenCalled();
-    });
-
-    describe("installs a view provider which", () => {
-        let provider;
-
-        beforeEach(() => {
-            provider =
-                mockmct.objectViews.addProvider.calls.mostRecent().args[0];
+            const plugin = new AutoflowTabularPlugin({ type: testType });
+            plugin(mockmct);
        });

-        it("applies its view to the type from options", () => {
-            expect(provider.canView(testObject)).toBe(true);
+        it("installs a view provider", function () {
+            expect(mockmct.objectViews.addProvider).toHaveBeenCalled();
        });

-        it("does not apply to other types", () => {
-            expect(provider.canView({ type: 'foo' })).toBe(false);
-        });
+        describe("installs a view provider which", function () {
+            let provider;

-        describe("provides a view which", () => {
-            let testKeys;
-            let testChildren;
-            let testContainer;
-            let testHistories;
-            let mockComposition;
-            let mockMetadata;
-            let mockEvaluator;
-            let mockUnsubscribes;
-            let callbacks;
-            let view;
-            let domObserver;
+            beforeEach(function () {
+                provider =
+                    mockmct.objectViews.addProvider.calls.mostRecent().args[0];
+            });

-            function waitsForChange() {
-                return new Promise(function (resolve) {
-                    window.requestAnimationFrame(resolve);
+            it("applies its view to the type from options", function () {
+                expect(provider.canView(testObject)).toBe(true);
+            });
+
+            it("does not apply to other types", function () {
+                expect(provider.canView({ type: 'foo' })).toBe(false);
+            });
+
+            describe("provides a view which", function () {
+                let testKeys;
+                let testChildren;
+                let testContainer;
+                let testHistories;
+                let mockComposition;
+                let mockMetadata;
+                let mockEvaluator;
+                let mockUnsubscribes;
+                let callbacks;
+                let view;
+                let domObserver;
+
+                function waitsForChange() {
+                    return new Promise(function (resolve) {
+                        window.requestAnimationFrame(resolve);
+                    });
+                }
+
+                function emitEvent(mockEmitter, type, event) {
+                    mockEmitter.on.calls.all().forEach(function (call) {
+                        if (call.args[0] === type) {
+                            call.args[1](event);
+                        }
+                    });
+                }
+
+                beforeEach(function () {
+                    callbacks = {};
+
+                    testObject = { type: 'some-type' };
+                    testKeys = ['abc', 'def', 'xyz'];
+                    testChildren = testKeys.map(function (key) {
+                        return {
+                            identifier: {
+                                namespace: "test",
+                                key: key
+                            },
+                            name: "Object " + key
+                        };
+                    });
+                    testContainer = $('<div>')[0];
+                    domObserver = new DOMObserver(testContainer);
+
+                    testHistories = testKeys.reduce(function (histories, key, index) {
+                        histories[key] = {
+                            key: key,
+                            range: index + 10,
+                            domain: key + index
+                        };
+
+                        return histories;
+                    }, {});
+
+                    mockComposition =
+                        jasmine.createSpyObj('composition', ['load', 'on', 'off']);
+                    mockMetadata =
+                        jasmine.createSpyObj('metadata', ['valuesForHints']);
+
+                    mockEvaluator = jasmine.createSpyObj('evaluator', ['evaluate']);
+                    mockUnsubscribes = testKeys.reduce(function (map, key) {
+                        map[key] = jasmine.createSpy('unsubscribe-' + key);
+
+                        return map;
+                    }, {});
+
+                    mockmct.composition.get.and.returnValue(mockComposition);
+                    mockComposition.load.and.callFake(function () {
+                        testChildren.forEach(emitEvent.bind(null, mockComposition, 'add'));
+
+                        return Promise.resolve(testChildren);
+                    });
+
+                    mockmct.telemetry.getMetadata.and.returnValue(mockMetadata);
+                    mockmct.telemetry.getValueFormatter.and.callFake(function (metadatum) {
+                        const mockFormatter = jasmine.createSpyObj('formatter', ['format']);
+                        mockFormatter.format.and.callFake(function (datum) {
+                            return datum[metadatum.hint];
+                        });
+
+                        return mockFormatter;
+                    });
+                    mockmct.telemetry.limitEvaluator.and.returnValue(mockEvaluator);
+                    mockmct.telemetry.subscribe.and.callFake(function (obj, callback) {
+                        const key = obj.identifier.key;
+                        callbacks[key] = callback;
+
+                        return mockUnsubscribes[key];
+                    });
+                    mockmct.telemetry.request.and.callFake(function (obj, request) {
+                        const key = obj.identifier.key;
+
+                        return Promise.resolve([testHistories[key]]);
+                    });
+                    mockMetadata.valuesForHints.and.callFake(function (hints) {
+                        return [{ hint: hints[0] }];
+                    });
+
+                    view = provider.view(testObject);
+                    view.show(testContainer);
+
+                    return waitsForChange();
                });
-            }

-            function emitEvent(mockEmitter, type, event) {
-                mockEmitter.on.calls.all().forEach((call) => {
-                    if (call.args[0] === type) {
-                        call.args[1](event);
+                afterEach(function () {
+                    domObserver.destroy();
+                });
+
+                it("populates its container", function () {
+                    expect(testContainer.children.length > 0).toBe(true);
+                });
+
+                describe("when rows have been populated", function () {
+                    function rowsMatch() {
+                        const rows = $(testContainer).find(".l-autoflow-row").length;
+
+                        return rows === testChildren.length;
                    }
-                });
-            }

-            beforeEach((done) => {
-                callbacks = {};
-
-                spyOnBuiltins(['requestAnimationFrame']);
-                window.requestAnimationFrame.and.callFake((callBack) => {
-                    callBack();
-                });
-
-                testObject = { type: 'some-type' };
-                testKeys = ['abc', 'def', 'xyz'];
-                testChildren = testKeys.map((key) => {
-                    return {
-                        identifier: {
-                            namespace: "test",
-                            key: key
-                        },
-                        name: "Object " + key
-                    };
-                });
-                testContainer = $('<div>')[0];
-                domObserver = new DOMObserver(testContainer);
-
-                testHistories = testKeys.reduce((histories, key, index) => {
-                    histories[key] = {
-                        key: key,
-                        range: index + 10,
-                        domain: key + index
-                    };
-
-                    return histories;
-                }, {});
-
-                mockComposition =
-                    jasmine.createSpyObj('composition', ['load', 'on', 'off']);
-                mockMetadata =
-                    jasmine.createSpyObj('metadata', ['valuesForHints']);
-
-                mockEvaluator = jasmine.createSpyObj('evaluator', ['evaluate']);
-                mockUnsubscribes = testKeys.reduce((map, key) => {
-                    map[key] = jasmine.createSpy('unsubscribe-' + key);
-
-                    return map;
-                }, {});
-
-                mockmct.composition.get.and.returnValue(mockComposition);
-                mockComposition.load.and.callFake(() => {
-                    testChildren.forEach(emitEvent.bind(null, mockComposition, 'add'));
-
-                    return Promise.resolve(testChildren);
-                });
-
-                mockmct.telemetry.getMetadata.and.returnValue(mockMetadata);
-                mockmct.telemetry.getValueFormatter.and.callFake((metadatum) => {
-                    const mockFormatter = jasmine.createSpyObj('formatter', ['format']);
-                    mockFormatter.format.and.callFake((datum) => {
-                        return datum[metadatum.hint];
+                    it("shows one row per child object", function () {
+                        return domObserver.when(rowsMatch);
                    });

-                    return mockFormatter;
-                });
-                mockmct.telemetry.limitEvaluator.and.returnValue(mockEvaluator);
-                mockmct.telemetry.subscribe.and.callFake((obj, callback) => {
-                    const key = obj.identifier.key;
-                    callbacks[key] = callback;
+                    it("adds rows on composition change", function () {
+                        const child = {
+                            identifier: {
+                                namespace: "test",
+                                key: "123"
+                            },
+                            name: "Object 123"
+                        };
+                        testChildren.push(child);
+                        emitEvent(mockComposition, 'add', child);

-                    return mockUnsubscribes[key];
-                });
-                mockmct.telemetry.request.and.callFake((obj, request) => {
-                    const key = obj.identifier.key;
-
-                    return Promise.resolve([testHistories[key]]);
-                });
-                mockMetadata.valuesForHints.and.callFake((hints) => {
-                    return [{ hint: hints[0] }];
-                });
-
-                view = provider.view(testObject);
-                view.show(testContainer);
-
-                return done();
-            });
-
-            afterEach(() => {
-                domObserver.destroy();
-            });
-
-            it("populates its container", () => {
-                expect(testContainer.children.length > 0).toBe(true);
-            });
-
-            describe("when rows have been populated", () => {
-                function rowsMatch() {
-                    const rows = $(testContainer).find(".l-autoflow-row").length;
-
-                    return rows === testChildren.length;
-                }
-
-                it("shows one row per child object", () => {
-                    return domObserver.when(rowsMatch);
-                });
-
-                // it("adds rows on composition change", () => {
-                //     const child = {
-                //         identifier: {
-                //             namespace: "test",
-                //             key: "123"
-                //         },
-                //         name: "Object 123"
-                //     };
-                //     testChildren.push(child);
-                //     emitEvent(mockComposition, 'add', child);
-
-                //     return domObserver.when(rowsMatch);
-                // });
-
-                it("removes rows on composition change", () => {
-                    const child = testChildren.pop();
-                    emitEvent(mockComposition, 'remove', child.identifier);
-
-                    return domObserver.when(rowsMatch);
-                });
-            });
-
-            it("removes subscriptions when destroyed", () => {
-                testKeys.forEach((key) => {
-                    expect(mockUnsubscribes[key]).not.toHaveBeenCalled();
-                });
-                view.destroy();
-                testKeys.forEach((key) => {
-                    expect(mockUnsubscribes[key]).toHaveBeenCalled();
-                });
-            });
-
-            it("provides a button to change column width", () => {
-                const initialWidth = AutoflowTabularConstants.INITIAL_COLUMN_WIDTH;
-                const nextWidth =
-                    initialWidth + AutoflowTabularConstants.COLUMN_WIDTH_STEP;
-
-                expect($(testContainer).find('.l-autoflow-col').css('width'))
-                    .toEqual(initialWidth + 'px');
-
-                $(testContainer).find('.change-column-width').click();
-
-                function widthHasChanged() {
-                    const width = $(testContainer).find('.l-autoflow-col').css('width');
-
-                    return width !== initialWidth + 'px';
-                }
-
-                return domObserver.when(widthHasChanged)
-                    .then(() => {
-                        expect($(testContainer).find('.l-autoflow-col').css('width'))
-                            .toEqual(nextWidth + 'px');
+                        return domObserver.when(rowsMatch);
                    });
-            });

-            it("subscribes to all child objects", () => {
-                testKeys.forEach((key) => {
-                    expect(callbacks[key]).toEqual(jasmine.any(Function));
-                });
-            });
+                    it("removes rows on composition change", function () {
+                        const child = testChildren.pop();
+                        emitEvent(mockComposition, 'remove', child.identifier);

-            it("displays historical telemetry", () => {
-                function rowTextDefined() {
-                    return $(testContainer).find(".l-autoflow-item").filter(".r").text() !== "";
-                }
-
-                return domObserver.when(rowTextDefined).then(() => {
-                    testKeys.forEach((key, index) => {
-                        const datum = testHistories[key];
-                        const $cell = $(testContainer).find(".l-autoflow-row").eq(index).find(".r");
-                        expect($cell.text()).toEqual(String(datum.range));
-                    });
-                });
-            });
-
-            it("displays incoming telemetry", () => {
-                const testData = testKeys.map((key, index) => {
-                    return {
-                        key: key,
-                        range: index * 100,
-                        domain: key + index
-                    };
-                });
-
-                testData.forEach((datum) => {
-                    callbacks[datum.key](datum);
-                });
-
-                return waitsForChange().then(() => {
-                    testData.forEach((datum, index) => {
-                        const $cell = $(testContainer).find(".l-autoflow-row").eq(index).find(".r");
-                        expect($cell.text()).toEqual(String(datum.range));
-                    });
-                });
-            });
-
-            it("updates classes for limit violations", () => {
-                const testClass = "some-limit-violation";
-                mockEvaluator.evaluate.and.returnValue({ cssClass: testClass });
-                testKeys.forEach((key) => {
-                    callbacks[key]({
-                        range: 'foo',
-                        domain: 'bar'
+                        return domObserver.when(rowsMatch);
                    });
                });

-                return waitsForChange().then(() => {
-                    testKeys.forEach((datum, index) => {
-                        const $cell = $(testContainer).find(".l-autoflow-row").eq(index).find(".r");
-                        expect($cell.hasClass(testClass)).toBe(true);
+                it("removes subscriptions when destroyed", function () {
+                    testKeys.forEach(function (key) {
+                        expect(mockUnsubscribes[key]).not.toHaveBeenCalled();
+                    });
+                    view.destroy();
+                    testKeys.forEach(function (key) {
+                        expect(mockUnsubscribes[key]).toHaveBeenCalled();
                    });
                });
-            });

-            it("automatically flows to new columns", () => {
-                const rowHeight = AutoflowTabularConstants.ROW_HEIGHT;
-                const sliderHeight = AutoflowTabularConstants.SLIDER_HEIGHT;
-                const count = testKeys.length;
-                const $container = $(testContainer);
-                let promiseChain = Promise.resolve();
+                it("provides a button to change column width", function () {
+                    const initialWidth = AutoflowTabularConstants.INITIAL_COLUMN_WIDTH;
+                    const nextWidth =
+                        initialWidth + AutoflowTabularConstants.COLUMN_WIDTH_STEP;

-                function columnsHaveAutoflowed() {
-                    const itemsHeight = $container.find('.l-autoflow-items').height();
-                    const availableHeight = itemsHeight - sliderHeight;
-                    const availableRows = Math.max(Math.floor(availableHeight / rowHeight), 1);
-                    const columns = Math.ceil(count / availableRows);
+                    expect($(testContainer).find('.l-autoflow-col').css('width'))
+                        .toEqual(initialWidth + 'px');

-                    return $container.find('.l-autoflow-col').length === columns;
-                }
+                    $(testContainer).find('.change-column-width').click();

-                $container.find('.abs').css({
-                    position: 'absolute',
-                    left: '0px',
-                    right: '0px',
-                    top: '0px',
-                    bottom: '0px'
+                    function widthHasChanged() {
+                        const width = $(testContainer).find('.l-autoflow-col').css('width');
+
+                        return width !== initialWidth + 'px';
+                    }
+
+                    return domObserver.when(widthHasChanged)
+                        .then(function () {
+                            expect($(testContainer).find('.l-autoflow-col').css('width'))
+                                .toEqual(nextWidth + 'px');
+                        });
                });
-                $container.css({ position: 'absolute' });

-                $container.appendTo(document.body);
-
-                function setHeight(height) {
-                    $container.css('height', height + 'px');
-
-                    return domObserver.when(columnsHaveAutoflowed);
-                }
-
-                for (let height = 0; height < rowHeight * count * 2; height += rowHeight / 2) {
-                    // eslint-disable-next-line no-invalid-this
-                    promiseChain = promiseChain.then(setHeight.bind(this, height));
-                }
-
-                return promiseChain.then(() => {
-                    $container.remove();
+                it("subscribes to all child objects", function () {
+                    testKeys.forEach(function (key) {
+                        expect(callbacks[key]).toEqual(jasmine.any(Function));
+                    });
                });
-            });

-            it("loads composition exactly once", () => {
-                const testObj = testChildren.pop();
-                emitEvent(mockComposition, 'remove', testObj.identifier);
-                testChildren.push(testObj);
-                emitEvent(mockComposition, 'add', testObj);
-                expect(mockComposition.load.calls.count()).toEqual(1);
+                it("displays historical telemetry", function () {
+                    function rowTextDefined() {
+                        return $(testContainer).find(".l-autoflow-item").filter(".r").text() !== "";
+                    }
+
+                    return domObserver.when(rowTextDefined).then(function () {
+                        testKeys.forEach(function (key, index) {
+                            const datum = testHistories[key];
+                            const $cell = $(testContainer).find(".l-autoflow-row").eq(index).find(".r");
+                            expect($cell.text()).toEqual(String(datum.range));
+                        });
+                    });
+                });
+
+                it("displays incoming telemetry", function () {
+                    const testData = testKeys.map(function (key, index) {
+                        return {
+                            key: key,
+                            range: index * 100,
+                            domain: key + index
+                        };
+                    });
+
+                    testData.forEach(function (datum) {
+                        callbacks[datum.key](datum);
+                    });
+
+                    return waitsForChange().then(function () {
+                        testData.forEach(function (datum, index) {
+                            const $cell = $(testContainer).find(".l-autoflow-row").eq(index).find(".r");
+                            expect($cell.text()).toEqual(String(datum.range));
+                        });
+                    });
+                });
+
+                it("updates classes for limit violations", function () {
+                    const testClass = "some-limit-violation";
+                    mockEvaluator.evaluate.and.returnValue({ cssClass: testClass });
+                    testKeys.forEach(function (key) {
+                        callbacks[key]({
+                            range: 'foo',
+                            domain: 'bar'
+                        });
+                    });
+
+                    return waitsForChange().then(function () {
+                        testKeys.forEach(function (datum, index) {
+                            const $cell = $(testContainer).find(".l-autoflow-row").eq(index).find(".r");
+                            expect($cell.hasClass(testClass)).toBe(true);
+                        });
+                    });
+                });
+
+                it("automatically flows to new columns", function () {
+                    const rowHeight = AutoflowTabularConstants.ROW_HEIGHT;
+                    const sliderHeight = AutoflowTabularConstants.SLIDER_HEIGHT;
+                    const count = testKeys.length;
+                    const $container = $(testContainer);
+                    let promiseChain = Promise.resolve();
+
+                    function columnsHaveAutoflowed() {
+                        const itemsHeight = $container.find('.l-autoflow-items').height();
+                        const availableHeight = itemsHeight - sliderHeight;
+                        const availableRows = Math.max(Math.floor(availableHeight / rowHeight), 1);
+                        const columns = Math.ceil(count / availableRows);
+
+                        return $container.find('.l-autoflow-col').length === columns;
+                    }
+
+                    $container.find('.abs').css({
+                        position: 'absolute',
+                        left: '0px',
+                        right: '0px',
+                        top: '0px',
+                        bottom: '0px'
+                    });
+                    $container.css({ position: 'absolute' });
+
+                    $container.appendTo(document.body);
+
+                    function setHeight(height) {
+                        $container.css('height', height + 'px');
+
+                        return domObserver.when(columnsHaveAutoflowed);
+                    }
+
+                    for (let height = 0; height < rowHeight * count * 2; height += rowHeight / 2) {
+                        // eslint-disable-next-line no-invalid-this
+                        promiseChain = promiseChain.then(setHeight.bind(this, height));
+                    }
+
+                    return promiseChain.then(function () {
+                        $container.remove();
+                    });
+                });
+
+                it("loads composition exactly once", function () {
+                    const testObj = testChildren.pop();
+                    emitEvent(mockComposition, 'remove', testObj.identifier);
+                    testChildren.push(testObj);
+                    emitEvent(mockComposition, 'add', testObj);
+                    expect(mockComposition.load.calls.count()).toEqual(1);
+                });
            });
        });
    });
--- a/src/plugins/condition/components/conditionals.scss
+++ b/src/plugins/condition/components/conditionals.scss
@@ -50,7 +50,6 @@
 .c-cs {
    display: flex;
    flex-direction: column;
-    flex: 1 1 auto;
    height: 100%;
    overflow: hidden;

--- a/src/plugins/condition/pluginSpec.js
+++ b/src/plugins/condition/pluginSpec.js
@@ -22,7 +22,6 @@

 import { createOpenMct, resetApplicationState } from "utils/testing";
 import ConditionPlugin from "./plugin";
-import stylesManager from '@/ui/inspector/styles/StylesManager';
 import StylesView from "./components/inspector/StylesView.vue";
 import Vue from 'vue';
 import {getApplicableStylesForItem} from "./utils/styleUtils";
@@ -403,8 +402,7 @@ describe('the plugin', function () {
            component = new Vue({
                provide: {
                    openmct: openmct,
-                    selection: selection,
-                    stylesManager
+                    selection: selection
                },
                el: viewContainer,
                components: {
--- a/src/plugins/displayLayout/CustomStringFormatter.js
+++ b/src/plugins/displayLayout/CustomStringFormatter.js
@@ -1,38 +0,0 @@
-import printj from 'printj';
-
-export default class CustomStringFormatter {
-    constructor(openmct, valueMetadata, itemFormat) {
-        this.openmct = openmct;
-
-        this.itemFormat = itemFormat;
-        this.valueMetadata = valueMetadata;
-    }
-
-    format(datum) {
-        if (!this.itemFormat) {
-            return;
-        }
-
-        if (!this.itemFormat.startsWith('&')) {
-            return printj.sprintf(this.itemFormat, datum[this.valueMetadata.key]);
-        }
-
-        try {
-            const key = this.itemFormat.slice(1);
-            const customFormatter = this.openmct.telemetry.getFormatter(key);
-            if (!customFormatter) {
-                throw new Error('Custom Formatter not found');
-            }
-
-            return customFormatter.format(datum[this.valueMetadata.key]);
-        } catch (e) {
-            console.error(e);
-
-            return datum[this.valueMetadata.key];
-        }
-    }
-
-    setFormat(itemFormat) {
-        this.itemFormat = itemFormat;
-    }
-}
--- a/src/plugins/displayLayout/CustomStringFormatterSpec.js
+++ b/src/plugins/displayLayout/CustomStringFormatterSpec.js
@@ -1,82 +0,0 @@
-import CustomStringFormatter from './CustomStringFormatter';
-import { createOpenMct, resetApplicationState } from 'utils/testing';
-
-const CUSTOM_FORMATS = [
-    {
-        key: 'sclk',
-        format: (value) => 2 * value
-    },
-    {
-        key: 'lts',
-        format: (value) => 3 * value
-    }
-];
-
-const valueMetadata = {
-    key: "sin",
-    name: "Sine",
-    unit: "Hz",
-    formatString: "%0.2f",
-    hints: {
-        range: 1,
-        priority: 3
-    },
-    source: "sin"
-};
-
-const datum = {
-    name: "1 Sine Wave Generator",
-    utc: 1603930354000,
-    yesterday: 1603843954000,
-    sin: 0.587785209686822,
-    cos: -0.8090170253297632
-};
-
-describe('CustomStringFormatter', function () {
-    let element;
-    let child;
-    let openmct;
-    let customStringFormatter;
-
-    beforeEach((done) => {
-        openmct = createOpenMct();
-
-        element = document.createElement('div');
-        child = document.createElement('div');
-        element.appendChild(child);
-        CUSTOM_FORMATS.forEach(openmct.telemetry.addFormat.bind({openmct}));
-        openmct.on('start', done);
-        openmct.startHeadless();
-
-        spyOn(openmct.telemetry, 'getFormatter');
-        openmct.telemetry.getFormatter.and.callFake((key) => CUSTOM_FORMATS.find(d => d.key === key));
-
-        customStringFormatter = new CustomStringFormatter(openmct, valueMetadata);
-    });
-
-    afterEach(() => {
-        return resetApplicationState(openmct);
-    });
-
-    it('adds custom format sclk', () => {
-        const format = openmct.telemetry.getFormatter('sclk');
-        expect(format.key).toEqual('sclk');
-    });
-
-    it('adds custom format lts', () => {
-        const format = openmct.telemetry.getFormatter('lts');
-        expect(format.key).toEqual('lts');
-    });
-
-    it('returns correct value for custom format sclk', () => {
-        customStringFormatter.setFormat('&sclk');
-        const value = customStringFormatter.format(datum, valueMetadata);
-        expect(datum.sin * 2).toEqual(value);
-    });
-
-    it('returns correct value for custom format lts', () => {
-        customStringFormatter.setFormat('&lts');
-        const value = customStringFormatter.format(datum, valueMetadata);
-        expect(datum.sin * 3).toEqual(value);
-    });
-});
--- a/src/plugins/displayLayout/actions/CopyToClipboardAction.js
+++ b/src/plugins/displayLayout/actions/CopyToClipboardAction.js
@@ -5,30 +5,29 @@ export default class CopyToClipboardAction {
        this.openmct = openmct;

        this.cssClass = 'icon-duplicate';
-        this.description = 'Copy value to clipboard';
+        this.description = 'Copy to Clipboard action';
        this.group = "action";
        this.key = 'copyToClipboard';
        this.name = 'Copy to Clipboard';
-        this.priority = 1;
+        this.priority = 9;
    }

-    invoke(objectPath, view = {}) {
-        const viewContext = view.getViewContext && view.getViewContext();
+    invoke(objectPath, viewContext) {
        const formattedValue = viewContext.formattedValueForCopy();
-
        clipboard.updateClipboard(formattedValue)
            .then(() => {
-                this.openmct.notifications.info(`Success : copied '${formattedValue}' to clipboard `);
+                this.openmct.notifications.info(`Success : copied to clipboard '${formattedValue}'`);
            })
            .catch(() => {
-                this.openmct.notifications.error(`Failed : to copy '${formattedValue}' to clipboard `);
+                this.openmct.notifications.error(`Failed : to copy to clipboard '${formattedValue}'`);
            });
    }

-    appliesTo(objectPath, view = {}) {
-        let viewContext = view.getViewContext && view.getViewContext();
+    appliesTo(objectPath, viewContext) {
+        if (viewContext && viewContext.getViewKey) {
+            return viewContext.getViewKey().includes('alphanumeric-format');
+        }

-        return viewContext && viewContext.formattedValueForCopy
-            && typeof viewContext.formattedValueForCopy === 'function';
+        return false;
    }
 }
--- a/src/plugins/displayLayout/components/TelemetryView.vue
+++ b/src/plugins/displayLayout/components/TelemetryView.vue
@@ -30,15 +30,18 @@
 >
    <div
        v-if="domainObject"
-        class="c-telemetry-view u-style-receiver"
-        :class="[statusClass]"
+        class="u-style-receiver c-telemetry-view"
+        :class="{
+            styleClass,
+            'is-missing': domainObject.status === 'missing'
+        }"
        :style="styleObject"
        :data-font-size="item.fontSize"
        :data-font="item.font"
        @contextmenu.prevent="showContextMenu"
    >
-        <div class="is-status__indicator"
-             :title="`This item is ${status}`"
+        <div class="is-missing__indicator"
+             title="This item is missing"
        ></div>
        <div
            v-if="showLabel"
@@ -71,6 +74,7 @@

 <script>
 import LayoutFrame from './LayoutFrame.vue';
+import printj from 'printj';
 import conditionalStylesMixin from "../mixins/objectStyles-mixin";
 import { getDefaultNotebook } from '@/plugins/notebook/utils/notebook-storage.js';

@@ -130,14 +134,10 @@ export default {
            datum: undefined,
            domainObject: undefined,
            formats: undefined,
-            viewKey: `alphanumeric-format-${Math.random()}`,
-            status: ''
+            viewKey: `alphanumeric-format-${Math.random()}`
        };
    },
    computed: {
-        statusClass() {
-            return (this.status) ? `is-status--${this.status}` : '';
-        },
        showLabel() {
            let displayMode = this.item.displayMode;

@@ -171,11 +171,7 @@ export default {
        valueMetadata() {
            return this.datum && this.metadata.value(this.item.value);
        },
-        formatter() {
-            if (this.item.format) {
-                return this.customStringformatter;
-            }
-
+        valueFormatter() {
            return this.formats[this.item.value];
        },
        telemetryValue() {
@@ -183,7 +179,11 @@ export default {
                return;
            }

-            return this.formatter && this.formatter.format(this.datum);
+            if (this.item.format) {
+                return printj.sprintf(this.item.format, this.datum[this.valueMetadata.key]);
+            }
+
+            return this.valueFormatter && this.valueFormatter.format(this.datum);
        },
        telemetryClass() {
            if (!this.datum) {
@@ -215,13 +215,9 @@ export default {
        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() {
        this.removeSubscription();
-        this.removeStatusListener();

        if (this.removeSelectable) {
            this.removeSelectable();
@@ -230,12 +226,17 @@ export default {
        this.openmct.time.off("bounds", this.refreshData);
    },
    methods: {
+        getViewContext() {
+            return {
+                getViewKey: () => this.viewKey,
+                formattedValueForCopy: this.formattedValueForCopy
+            };
+        },
        formattedValueForCopy() {
            const timeFormatterKey = this.openmct.time.timeSystem().key;
            const timeFormatter = this.formats[timeFormatterKey];
-            const unit = this.unit ? ` ${this.unit}` : '';

-            return `At ${timeFormatter.format(this.datum)} ${this.domainObject.name} had a value of ${this.telemetryValue}${unit}`;
+            return `At ${timeFormatter.format(this.datum)} ${this.domainObject.name} had a value of ${this.telemetryValue} ${this.unit}`;
        },
        requestHistoricalData() {
            let bounds = this.openmct.time.bounds();
@@ -276,10 +277,10 @@ export default {
        },
        getView() {
            return {
-                getViewContext: () => {
+                getViewContext() {
                    return {
                        viewHistoricalData: true,
-                        formattedValueForCopy: this.formattedValueForCopy
+                        skipCache: true
                    };
                }
            };
@@ -290,10 +291,6 @@ export default {
            this.metadata = this.openmct.telemetry.getMetadata(this.domainObject);
            this.limitEvaluator = this.openmct.telemetry.limitEvaluator(this.domainObject);
            this.formats = this.openmct.telemetry.getFormatMap(this.metadata);
-
-            const valueMetadata = this.metadata.value(this.item.value);
-            this.customStringformatter = this.openmct.telemetry.customStringFormatter(valueMetadata, this.item.format);
-
            this.requestHistoricalData();
            this.subscribeToObject();

@@ -311,39 +308,37 @@ export default {
            this.removeSelectable = this.openmct.selection.selectable(
                this.$el, this.context, this.immediatelySelect || this.initSelect);
            delete this.immediatelySelect;
+
+            let allActions = this.openmct.actions.get(this.currentObjectPath, this.getView());
+
+            this.applicableActions = CONTEXT_MENU_ACTIONS.map(actionKey => {
+                return allActions[actionKey];
+            });
        },
        updateTelemetryFormat(format) {
-            this.customStringformatter.setFormat(format);
-
            this.$emit('formatChanged', this.item, format);
        },
        async getContextMenuActions() {
            const defaultNotebook = getDefaultNotebook();
            const domainObject = defaultNotebook && await this.openmct.objects.get(defaultNotebook.notebookMeta.identifier);
-            const actionCollection = this.openmct.actions.get(this.currentObjectPath, this.getView());
-            const actionsObject = actionCollection.getActionsObject();

-            let copyToNotebookAction = actionsObject.copyToNotebook;
+            const actionsObject = this.openmct.actions.get(this.currentObjectPath, this.getViewContext(), { viewHistoricalData: true }).applicableActions;
+            let applicableActionKeys = Object.keys(actionsObject)
+                .filter(key => {
+                    const isCopyToNotebook = actionsObject[key].key === 'copyToNotebook';
+                    if (defaultNotebook && isCopyToNotebook) {
+                        const defaultPath = domainObject && `${domainObject.name} - ${defaultNotebook.section.name} - ${defaultNotebook.page.name}`;
+                        actionsObject[key].name = `Copy to Notebook ${defaultPath}`;
+                    }

-            if (defaultNotebook) {
-                const defaultPath = domainObject && `${domainObject.name} - ${defaultNotebook.section.name} - ${defaultNotebook.page.name}`;
-                copyToNotebookAction.name = `Copy to Notebook ${defaultPath}`;
-            } else {
-                actionsObject.copyToNotebook = undefined;
-                delete actionsObject.copyToNotebook;
-            }
+                    return CONTEXT_MENU_ACTIONS.includes(actionsObject[key].key);
+                });

-            return CONTEXT_MENU_ACTIONS.map(actionKey => {
-                return actionsObject[actionKey];
-            }).filter(action => action !== undefined);
+            return applicableActionKeys.map(key => actionsObject[key]);
        },
        async showContextMenu(event) {
            const contextMenuActions = await this.getContextMenuActions();
-
            this.openmct.menus.showMenu(event.x, event.y, contextMenuActions);
-        },
-        setStatus(status) {
-            this.status = status;
        }
    }
 };
--- a/src/plugins/displayLayout/components/telemetry-view.scss
+++ b/src/plugins/displayLayout/components/telemetry-view.scss
@@ -7,6 +7,7 @@
        flex: 1 1 auto;
        display: flex;
        flex-direction: row;
+       // justify-content: center;
        align-items: center;
        overflow: hidden;
        padding: $interiorMargin;
@@ -26,13 +27,14 @@
        border: 1px solid transparent;
    }

-    .is-status__indicator {
-        position: absolute;
+    @include isMissing($absPos: true);
+
+    .is-missing__indicator {
        top: 0;
        left: 0;
    }

-    &[class*='is-status'] {
+    &.is-missing {
        border: $borderMissing;
    }
 }
--- a/src/plugins/duplicate/DuplicateAction.js
+++ b/src/plugins/duplicate/DuplicateAction.js
@@ -1,159 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-import DuplicateTask from './DuplicateTask';
-
-export default class DuplicateAction {
-    constructor(openmct) {
-        this.name = 'Duplicate';
-        this.key = 'duplicate';
-        this.description = 'Duplicate this object.';
-        this.cssClass = "icon-duplicate";
-        this.group = "action";
-        this.priority = 7;
-
-        this.openmct = openmct;
-    }
-
-    async invoke(objectPath) {
-        let duplicationTask = new DuplicateTask(this.openmct);
-        let originalObject = objectPath[0];
-        let parent = objectPath[1];
-        let userInput = await this.getUserInput(originalObject, parent);
-        let newParent = userInput.location;
-        let inNavigationPath = this.inNavigationPath(originalObject);
-
-        // legacy check
-        if (this.isLegacyDomainObject(newParent)) {
-            newParent = await this.convertFromLegacy(newParent);
-        }
-
-        // if editing, save
-        if (inNavigationPath && this.openmct.editor.isEditing()) {
-            this.openmct.editor.save();
-        }
-
-        // duplicate
-        let newObject = await duplicationTask.duplicate(originalObject, newParent);
-        this.updateNameCheck(newObject, userInput.name);
-
-        return;
-    }
-
-    async getUserInput(originalObject, parent) {
-        let dialogService = this.openmct.$injector.get('dialogService');
-        let dialogForm = this.getDialogForm(originalObject, parent);
-        let formState = {
-            name: originalObject.name
-        };
-        let userInput = await dialogService.getUserInput(dialogForm, formState);
-
-        return userInput;
-    }
-
-    updateNameCheck(object, name) {
-        if (object.name !== name) {
-            this.openmct.objects.mutate(object, 'name', name);
-        }
-    }
-
-    inNavigationPath(object) {
-        return this.openmct.router.path
-            .some(objectInPath => this.openmct.objects.areIdsEqual(objectInPath.identifier, object.identifier));
-    }
-
-    getDialogForm(object, parent) {
-        return {
-            name: "Duplicate Item",
-            sections: [
-                {
-                    rows: [
-                        {
-                            key: "name",
-                            control: "textfield",
-                            name: "Name",
-                            pattern: "\\S+",
-                            required: true,
-                            cssClass: "l-input-lg"
-                        },
-                        {
-                            name: "location",
-                            cssClass: "grows",
-                            control: "locator",
-                            validate: this.validate(object, parent),
-                            key: 'location'
-                        }
-                    ]
-                }
-            ]
-        };
-    }
-
-    validate(object, currentParent) {
-        return (parentCandidate) => {
-            let currentParentKeystring = this.openmct.objects.makeKeyString(currentParent.identifier);
-            let parentCandidateKeystring = this.openmct.objects.makeKeyString(parentCandidate.getId());
-            let objectKeystring = this.openmct.objects.makeKeyString(object.identifier);
-
-            if (!parentCandidate || !currentParentKeystring) {
-                return false;
-            }
-
-            if (parentCandidateKeystring === objectKeystring) {
-                return false;
-            }
-
-            return this.openmct.composition.checkPolicy(
-                parentCandidate.useCapability('adapter'),
-                object
-            );
-        };
-    }
-
-    isLegacyDomainObject(domainObject) {
-        return domainObject.getCapability !== undefined;
-    }
-
-    async convertFromLegacy(legacyDomainObject) {
-        let objectContext = legacyDomainObject.getCapability('context');
-        let domainObject = await this.openmct.objects.get(objectContext.domainObject.id);
-
-        return domainObject;
-    }
-
-    appliesTo(objectPath) {
-        let parent = objectPath[1];
-        let parentType = parent && this.openmct.types.get(parent.type);
-        let child = objectPath[0];
-        let childType = child && this.openmct.types.get(child.type);
-        let locked = child.locked ? child.locked : parent && parent.locked;
-
-        if (locked) {
-            return false;
-        }
-
-        return childType
-            && childType.definition.creatable
-            && parentType
-            && parentType.definition.creatable
-            && Array.isArray(parent.composition);
-    }
-}
--- a/src/plugins/duplicate/DuplicateTask.js
+++ b/src/plugins/duplicate/DuplicateTask.js
@@ -1,273 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-
-import uuid from 'uuid';
-
-/**
- * This class encapsulates the process of  duplicating/copying a domain object
- * and all of its children.
- *
- * @param {DomainObject} domainObject The object to duplicate
- * @param {DomainObject} parent The new location of the cloned object tree
- * @param {src/plugins/duplicate.DuplicateService~filter} filter
- *        a function used to filter out objects from
- *        the cloning process
- * @constructor
- */
-export default class DuplicateTask {
-
-    constructor(openmct) {
-        this.domainObject = undefined;
-        this.parent = undefined;
-        this.firstClone = undefined;
-        this.filter = undefined;
-        this.persisted = 0;
-        this.clones = [];
-        this.idMap = {};
-
-        this.openmct = openmct;
-    }
-
-    /**
-     * Execute the duplicate/copy task with the objects provided.
-     * @returns {promise} Which will resolve with a clone of the object
-     * once complete.
-     */
-    async duplicate(domainObject, parent, filter) {
-        this.domainObject = domainObject;
-        this.parent = parent;
-        this.namespace = parent.identifier.namespace;
-        this.filter = filter || this.isCreatable;
-
-        await this.buildDuplicationPlan();
-        await this.persistObjects();
-        await this.addClonesToParent();
-
-        return this.firstClone;
-    }
-
-    /**
-     * Will build a graph of an object and all of its child objects in
-     * memory
-     * @private
-     * @param domainObject The original object to be copied
-     * @param parent The parent of the original object to be copied
-     * @returns {Promise} resolved with an array of clones of the models
-     * of the object tree being copied. Duplicating is done in a bottom-up
-     * fashion, so that the last member in the array is a clone of the model
-     * object being copied. The clones are all full composed with
-     * references to their own children.
-     */
-    async buildDuplicationPlan() {
-        let domainObjectClone = await this.duplicateObject(this.domainObject);
-
-        if (domainObjectClone !== this.domainObject) {
-            domainObjectClone.location = this.getKeyString(this.parent);
-        }
-
-        this.firstClone = domainObjectClone;
-
-        return;
-    }
-
-    /**
-     * Will persist a list of {@link objectClones}. It will persist all
-     * simultaneously, irrespective of order in the list. This may
-     * result in automatic request batching by the browser.
-     */
-    async persistObjects() {
-        let initialCount = this.clones.length;
-        let dialog = this.openmct.overlays.progressDialog({
-            progressPerc: 0,
-            message: `Duplicating ${initialCount} objects.`,
-            iconClass: 'info',
-            title: 'Duplicating'
-        });
-
-        let clonesDone = Promise.all(this.clones.map((clone) => {
-            let percentPersisted = Math.ceil(100 * (++this.persisted / initialCount));
-            let message = `Duplicating ${initialCount - this.persisted} objects.`;
-
-            dialog.updateProgress(percentPersisted, message);
-
-            return this.openmct.objects.save(clone);
-        }));
-
-        await clonesDone;
-
-        dialog.dismiss();
-        this.openmct.notifications.info(`Duplicated ${this.persisted} objects.`);
-
-        return;
-    }
-
-    /**
-     * Will add a list of clones to the specified parent's composition
-     */
-    async addClonesToParent() {
-        let parentComposition = this.openmct.composition.get(this.parent);
-        await parentComposition.load();
-        parentComposition.add(this.firstClone);
-
-        return;
-    }
-
-    /**
-     * A recursive function that will perform a bottom-up duplicate of
-     * the object tree with originalObject at the root. Recurses to
-     * the farthest leaf, then works its way back up again,
-     * cloning objects, and composing them with their child clones
-     * as it goes
-     * @private
-     * @returns {DomainObject} If the type of the original object allows for
-     * duplication, then a duplicate of the object, otherwise the object
-     * itself (to allow linking to non duplicatable objects).
-     */
-    async duplicateObject(originalObject) {
-        // Check if the creatable (or other passed in filter).
-        if (this.filter(originalObject)) {
-            let clone = this.cloneObjectModel(originalObject);
-            let composeesCollection = this.openmct.composition.get(originalObject);
-            let composees;
-
-            if (composeesCollection) {
-                composees = await composeesCollection.load();
-            }
-
-            return this.duplicateComposees(clone, composees);
-        }
-
-        // Not creatable, creating a link, no need to iterate children
-        return originalObject;
-    }
-
-    /**
-     * Given an array of objects composed by a parent, clone them, then
-     * add them to the parent.
-     * @private
-     * @returns {*}
-     */
-    async duplicateComposees(clonedParent, composees = []) {
-        let idMappings = [];
-        let allComposeesDuplicated = composees.reduce(async (previousPromise, nextComposee) => {
-            await previousPromise;
-
-            let clonedComposee = await this.duplicateObject(nextComposee);
-
-            if (clonedComposee) {
-                idMappings.push({
-                    newId: clonedComposee.identifier,
-                    oldId: nextComposee.identifier
-                });
-                this.composeChild(clonedComposee, clonedParent, clonedComposee !== nextComposee);
-            }
-
-            return;
-        }, Promise.resolve());
-
-        await allComposeesDuplicated;
-
-        clonedParent = this.rewriteIdentifiers(clonedParent, idMappings);
-        this.clones.push(clonedParent);
-
-        return clonedParent;
-    }
-
-    /**
-     * Update identifiers in a cloned object model (or part of
-     * a cloned object model) to reflect new identifiers after
-     * duplicating.
-     * @private
-     */
-    rewriteIdentifiers(clonedParent, childIdMappings) {
-        for (let { newId, oldId } of childIdMappings) {
-            let newIdKeyString = this.openmct.objects.makeKeyString(newId);
-            let oldIdKeyString = this.openmct.objects.makeKeyString(oldId);
-
-            // regex replace keystrings
-            clonedParent = JSON.stringify(clonedParent).replace(new RegExp(oldIdKeyString, 'g'), newIdKeyString);
-
-            // parse reviver to replace identifiers
-            clonedParent = JSON.parse(clonedParent, (key, value) => {
-                if (Object.prototype.hasOwnProperty.call(value, 'key')
-                    && Object.prototype.hasOwnProperty.call(value, 'namespace')
-                    && value.key === oldId.key
-                    && value.namespace === oldId.namespace) {
-                    return newId;
-                } else {
-                    return value;
-                }
-            });
-        }
-
-        return clonedParent;
-    }
-
-    composeChild(child, parent, setLocation) {
-        parent.composition.push(child.identifier);
-
-        //If a location is not specified, set it.
-        if (setLocation && child.location === undefined) {
-            let parentKeyString = this.getKeyString(parent);
-            child.location = parentKeyString;
-        }
-    }
-
-    getTypeDefinition(domainObject, definition) {
-        let typeDefinitions = this.openmct.types.get(domainObject.type).definition;
-
-        return typeDefinitions[definition] || false;
-    }
-
-    cloneObjectModel(domainObject) {
-        let clone = JSON.parse(JSON.stringify(domainObject));
-        let identifier = {
-            key: uuid(),
-            namespace: this.namespace // set to NEW parent's namespace
-        };
-
-        if (clone.modified || clone.persisted || clone.location) {
-            clone.modified = undefined;
-            clone.persisted = undefined;
-            clone.location = undefined;
-            delete clone.modified;
-            delete clone.persisted;
-            delete clone.location;
-        }
-
-        if (clone.composition) {
-            clone.composition = [];
-        }
-
-        clone.identifier = identifier;
-
-        return clone;
-    }
-
-    getKeyString(domainObject) {
-        return this.openmct.objects.makeKeyString(domainObject.identifier);
-    }
-
-    isCreatable(domainObject) {
-        return this.getTypeDefinition(domainObject, 'creatable');
-    }
-}
--- a/src/plugins/duplicate/pluginSpec.js
+++ b/src/plugins/duplicate/pluginSpec.js
@@ -1,157 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-import DuplicateActionPlugin from './plugin.js';
-import DuplicateAction from './DuplicateAction.js';
-import DuplicateTask from './DuplicateTask.js';
-import {
-    createOpenMct,
-    resetApplicationState,
-    getMockObjects
-} from 'utils/testing';
-
-describe("The Duplicate Action plugin", () => {
-
-    let openmct;
-    let duplicateTask;
-    let childObject;
-    let parentObject;
-    let anotherParentObject;
-
-    // this setups up the app
-    beforeEach((done) => {
-        openmct = createOpenMct();
-
-        childObject = getMockObjects({
-            objectKeyStrings: ['folder'],
-            overwrite: {
-                folder: {
-                    name: "Child Folder",
-                    identifier: {
-                        namespace: "",
-                        key: "child-folder-object"
-                    }
-                }
-            }
-        }).folder;
-        parentObject = getMockObjects({
-            objectKeyStrings: ['folder'],
-            overwrite: {
-                folder: {
-                    name: "Parent Folder",
-                    composition: [childObject.identifier]
-                }
-            }
-        }).folder;
-        anotherParentObject = getMockObjects({
-            objectKeyStrings: ['folder'],
-            overwrite: {
-                folder: {
-                    name: "Another Parent Folder"
-                }
-            }
-        }).folder;
-
-        let objectGet = openmct.objects.get.bind(openmct.objects);
-        spyOn(openmct.objects, 'get').and.callFake((identifier) => {
-            let obj = [childObject, parentObject, anotherParentObject].find((ob) => ob.identifier.key === identifier.key);
-
-            if (!obj) {
-                // not one of the mocked objs, callthrough basically
-                return objectGet(identifier);
-            }
-
-            return Promise.resolve(obj);
-        });
-
-        spyOn(openmct.composition, 'get').and.callFake((domainObject) => {
-            return {
-                load: async () => {
-                    let obj = [childObject, parentObject, anotherParentObject].find((ob) => ob.identifier.key === domainObject.identifier.key);
-                    let children = [];
-
-                    if (obj) {
-                        for (let i = 0; i < obj.composition.length; i++) {
-                            children.push(await openmct.objects.get(obj.composition[i]));
-                        }
-                    }
-
-                    return Promise.resolve(children);
-                },
-                add: (child) => {
-                    domainObject.composition.push(child.identifier);
-                }
-            };
-        });
-
-        // already installed by default, but never hurts, just adds to context menu
-        openmct.install(DuplicateActionPlugin());
-
-        openmct.on('start', done);
-        openmct.startHeadless();
-    });
-
-    afterEach(() => {
-        resetApplicationState(openmct);
-    });
-
-    it("should be defined", () => {
-        expect(DuplicateActionPlugin).toBeDefined();
-    });
-
-    describe("when moving an object to a new parent", () => {
-
-        beforeEach(async (done) => {
-            duplicateTask = new DuplicateTask(openmct);
-            await duplicateTask.duplicate(parentObject, anotherParentObject);
-            done();
-        });
-
-        it("the duplicate child object's name (when not changing) should be the same as the original object", async () => {
-            let duplicatedObjectIdentifier = anotherParentObject.composition[0];
-            let duplicatedObject = await openmct.objects.get(duplicatedObjectIdentifier);
-            let duplicateObjectName = duplicatedObject.name;
-
-            expect(duplicateObjectName).toEqual(parentObject.name);
-        });
-
-        it("the duplicate child object's identifier should be new", () => {
-            let duplicatedObjectIdentifier = anotherParentObject.composition[0];
-
-            expect(duplicatedObjectIdentifier.key).not.toEqual(parentObject.identifier.key);
-        });
-    });
-
-    describe("when a new name is provided for the duplicated object", () => {
-        const NEW_NAME = 'New Name';
-
-        beforeEach(() => {
-            duplicateTask = new DuplicateAction(openmct);
-            duplicateTask.updateNameCheck(parentObject, NEW_NAME);
-        });
-
-        it("the name is updated", () => {
-            let childName = parentObject.name;
-            expect(childName).toEqual(NEW_NAME);
-        });
-    });
-
-});
--- a/src/plugins/folderView/components/GridItem.vue
+++ b/src/plugins/folderView/components/GridItem.vue
@@ -1,10 +1,11 @@
 <template>
 <a
    class="l-grid-view__item c-grid-item"
-    :class="[{
+    :class="{
        'is-alias': item.isAlias === true,
+        'is-missing': item.model.status === 'missing',
        'c-grid-item--unknown': item.type.cssClass === undefined || item.type.cssClass.indexOf('unknown') !== -1
-    }, statusClass]"
+    }"
    :href="objectLink"
 >
    <div
@@ -26,8 +27,8 @@
        </div>
    </div>
    <div class="c-grid-item__controls">
-        <div class="is-status__indicator"
-             :title="`This item is ${status}`"
+        <div class="is-missing__indicator"
+             title="This item is missing"
        ></div>
        <div
            class="icon-people"
@@ -45,10 +46,9 @@
 <script>
 import contextMenuGesture from '../../../ui/mixins/context-menu-gesture';
 import objectLink from '../../../ui/mixins/object-link';
-import statusListener from './status-listener';

 export default {
-    mixins: [contextMenuGesture, objectLink, statusListener],
+    mixins: [contextMenuGesture, objectLink],
    props: {
        item: {
            type: Object,
--- a/src/plugins/folderView/components/ListItem.vue
+++ b/src/plugins/folderView/components/ListItem.vue
@@ -8,15 +8,15 @@
        <a
            ref="objectLink"
            class="c-object-label"
-            :class="[statusClass]"
+            :class="{ 'is-missing': item.model.status === 'missing' }"
            :href="objectLink"
        >
            <div
                class="c-object-label__type-icon c-list-item__name__type-icon"
                :class="item.type.cssClass"
            >
-                <span class="is-status__indicator"
-                      :title="`This item is ${status}`"
+                <span class="is-missing__indicator"
+                      title="This item is missing"
                ></span>
            </div>
            <div class="c-object-label__name c-list-item__name__name">{{ item.model.name }}</div>
@@ -39,10 +39,9 @@
 import moment from 'moment';
 import contextMenuGesture from '../../../ui/mixins/context-menu-gesture';
 import objectLink from '../../../ui/mixins/object-link';
-import statusListener from './status-listener';

 export default {
-    mixins: [contextMenuGesture, objectLink, statusListener],
+    mixins: [contextMenuGesture, objectLink],
    props: {
        item: {
            type: Object,
--- a/src/plugins/folderView/components/grid-item.scss
+++ b/src/plugins/folderView/components/grid-item.scss
@@ -0,0 +1,121 @@
+/******************************* GRID ITEMS */
+.c-grid-item {
+    // Mobile-first
+    @include button($bg: $colorItemBg, $fg: $colorItemFg);
+    cursor: pointer;
+    display: flex;
+    padding: $interiorMarginLg;
+
+    &__type-icon {
+        filter: $colorKeyFilter;
+        flex: 0 0 $gridItemMobile;
+        font-size: floor($gridItemMobile / 2);
+        margin-right: $interiorMarginLg;
+    }
+
+    &.is-alias {
+        // Object is an alias to an original.
+        [class*='__type-icon'] {
+            @include isAlias();
+            color: $colorIconAliasForKeyFilter;
+        }
+    }
+
+    &__details {
+        display: flex;
+        flex-flow: column nowrap;
+        flex: 1 1 auto;
+    }
+
+    &__name {
+        @include ellipsize();
+        color: $colorItemFg;
+        @include headerFont(1.2em);
+        margin-bottom: $interiorMarginSm;
+    }
+
+    &__metadata {
+        color: $colorItemFgDetails;
+        font-size: 0.9em;
+
+        body.mobile & {
+            [class*='__item-count'] {
+                &:before {
+                    content: ' - ';
+                }
+            }
+        }
+    }
+
+    &__controls {
+        color: $colorItemFgDetails;
+        flex: 0 0 64px;
+        font-size: 1.2em;
+        display: flex;
+        align-items: center;
+        justify-content: flex-end;
+
+        > * + * {
+            margin-left: $interiorMargin;
+        }
+    }
+
+    body.desktop & {
+        $transOutMs: 300ms;
+        flex-flow: column nowrap;
+        transition: background $transOutMs ease-in-out;
+
+        &:hover {
+            background: $colorItemBgHov;
+            transition: $transIn;
+
+            .c-grid-item__type-icon {
+                filter: $colorKeyFilterHov;
+                transform: scale(1);
+                transition: $transInBounce;
+            }
+        }
+
+        > * {
+            margin: 0; // Reset from mobile
+        }
+
+        &__controls {
+            align-items: start;
+            flex: 0 0 auto;
+            order: 1;
+            .c-info-button,
+            .c-pointer-icon { display: none; }
+        }
+
+        &__type-icon {
+            flex: 1 1 auto;
+            font-size: floor($gridItemDesk / 3);
+            margin: $interiorMargin 22.5% $interiorMargin * 3 22.5%;
+            order: 2;
+            transform: scale(0.9);
+            transform-origin: center;
+            transition: all $transOutMs ease-in-out;
+        }
+
+        &__details {
+            flex: 0 0 auto;
+            justify-content: flex-end;
+            order: 3;
+        }
+
+        &__metadata {
+            display: flex;
+
+            &__type {
+                flex: 1 1 auto;
+                @include ellipsize();
+            }
+
+            &__item-count {
+                opacity: 0.7;
+                flex: 0 0 auto;
+            }
+        }
+    }
+}
--- a/src/plugins/folderView/components/grid-view.scss
+++ b/src/plugins/folderView/components/grid-view.scss
@@ -11,8 +11,6 @@

    body.desktop & {
        flex-flow: row wrap;
-        align-content: flex-start;
-
        &__item {
            height: $gridItemDesk;
            width: $gridItemDesk;
@@ -43,20 +41,9 @@
        }
    }

-    &.is-status--notebook-default {
-        .is-status__indicator {
-            display: block;
+    &.is-missing {
+        @include isMissing();

-            &:before {
-                color: $colorFilter;
-                content: $glyph-icon-notebook-page;
-                font-family: symbolsfont;
-            }
-        }
-    }
-
-    &[class*='is-status--missing'],
-    &[class*='is-status--suspect']{
        [class*='__type-icon'],
        [class*='__details'] {
            opacity: $opacityMissing;
--- a/src/plugins/folderView/components/status-listener.js
+++ b/src/plugins/folderView/components/status-listener.js
@@ -1,33 +0,0 @@
-export default {
-    inject: ['openmct'],
-    props: {
-        item: {
-            type: Object,
-            required: true
-        }
-    },
-    computed: {
-        statusClass() {
-            return (this.status) ? `is-status--${this.status}` : '';
-        }
-    },
-    data() {
-        return {
-            status: ''
-        };
-    },
-    methods: {
-        setStatus(status) {
-            this.status = status;
-        }
-    },
-    mounted() {
-        let identifier = this.item.model.identifier;
-
-        this.status = this.openmct.status.get(identifier);
-        this.removeStatusListener = this.openmct.status.observe(identifier, this.setStatus);
-    },
-    destroyed() {
-        this.removeStatusListener();
-    }
-};
--- a/src/plugins/imagery/components/ImageryViewLayout.vue
+++ b/src/plugins/imagery/components/ImageryViewLayout.vue
@@ -36,7 +36,7 @@
        <div class="c-imagery__main-image__bg"
             :class="{'paused unnsynced': isPaused,'stale':false }"
        >
-            <div class="c-imagery__main-image__image js-imageryView-image"
+            <div class="c-imagery__main-image__image"
                 :style="{
                     'background-image': imageUrl ? `url(${imageUrl})` : 'none',
                     'filter': `brightness(${filters.brightness}%) contrast(${filters.contrast}%)`
@@ -137,8 +137,7 @@ export default {
            refreshCSS: false,
            keyString: undefined,
            focusedImageIndex: undefined,
-            numericDuration: undefined,
-            telemetryCollection: undefined
+            numericDuration: undefined
        };
    },
    computed: {
@@ -223,7 +222,6 @@ export default {
        // kickoff
        this.subscribe();
        this.requestHistory();
-        this.requestTelemetry();
    },
    updated() {
        this.scrollToRight();
@@ -355,15 +353,6 @@ export default {
                this.requestHistory();
            }
        },
-        async requestTelemetry() {
-            this.telemetryCollection = await this.openmct.telemetry.requestTelemetryCollection(this.domainObject);
-            this.telemetryCollection.on('add', (data) => {
-                console.log('added data', data);
-            });
-            this.telemetryCollection.on('remove', (data) => {
-                console.log('removed data', data);
-            });
-        },
        async requestHistory() {
            let bounds = this.openmct.time.bounds();
            this.requestCount++;
--- a/src/plugins/imagery/components/imagery-view-layout.scss
+++ b/src/plugins/imagery/components/imagery-view-layout.scss
@@ -1,8 +1,8 @@
 .c-imagery {
    display: flex;
    flex-direction: column;
-    flex: 1 1 auto;
    overflow: hidden;
+    height: 100%;

    &:focus {
        outline: none;
@@ -19,10 +19,14 @@
    }

    &__main-image {
+        &__bg,
+        &__image {
+            height: 100%;
+        }
+
        &__bg {
            background-color: $colorPlotBg;
            border: 1px solid transparent;
-            flex: 1 1 auto;

            &.unnsynced{
                @include sUnsynced();
@@ -30,7 +34,6 @@
        }

        &__image {
-            @include abs(); // Safari fix
            background-position: center;
            background-repeat: no-repeat;
            background-size: contain;
--- a/src/plugins/imagery/pluginSpec.js
+++ b/src/plugins/imagery/pluginSpec.js
@@ -1,306 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-import ImageryPlugin from './plugin.js';
-import Vue from 'vue';
-import {
-    createOpenMct,
-    resetApplicationState,
-    simulateKeyEvent
-} from 'utils/testing';
-
-const ONE_MINUTE = 1000 * 60;
-const TEN_MINUTES = ONE_MINUTE * 10;
-const MAIN_IMAGE_CLASS = '.js-imageryView-image';
-const NEW_IMAGE_CLASS = '.c-imagery__age.c-imagery--new';
-const REFRESH_CSS_MS = 500;
-
-function getImageInfo(doc) {
-    let imageElement = doc.querySelectorAll(MAIN_IMAGE_CLASS)[0];
-    let timestamp = imageElement.dataset.openmctImageTimestamp;
-    let identifier = imageElement.dataset.openmctObjectKeystring;
-    let url = imageElement.style.backgroundImage;
-
-    return {
-        timestamp,
-        identifier,
-        url
-    };
-}
-
-function isNew(doc) {
-    let newIcon = doc.querySelectorAll(NEW_IMAGE_CLASS);
-
-    return newIcon.length !== 0;
-}
-
-function generateTelemetry(start, count) {
-    let telemetry = [];
-
-    for (let i = 1, l = count + 1; i < l; i++) {
-        let stringRep = i + 'minute';
-        let logo = 'images/logo-openmct.svg';
-
-        telemetry.push({
-            "name": stringRep + " Imagery",
-            "utc": start + (i * ONE_MINUTE),
-            "url": location.host + '/' + logo + '?time=' + stringRep,
-            "timeId": stringRep
-        });
-    }
-
-    return telemetry;
-}
-
-describe("The Imagery View Layout", () => {
-    const imageryKey = 'example.imagery';
-    const START = Date.now();
-    const COUNT = 10;
-
-    let openmct;
-    let imageryPlugin;
-    let parent;
-    let child;
-    let timeFormat = 'utc';
-    let bounds = {
-        start: START - TEN_MINUTES,
-        end: START
-    };
-    let imageTelemetry = generateTelemetry(START - TEN_MINUTES, COUNT);
-    let imageryObject = {
-        identifier: {
-            namespace: "",
-            key: "imageryId"
-        },
-        name: "Example Imagery",
-        type: "example.imagery",
-        location: "parentId",
-        modified: 0,
-        persisted: 0,
-        telemetry: {
-            values: [
-                {
-                    "name": "Image",
-                    "key": "url",
-                    "format": "image",
-                    "hints": {
-                        "image": 1,
-                        "priority": 3
-                    },
-                    "source": "url"
-                },
-                {
-                    "name": "Name",
-                    "key": "name",
-                    "source": "name",
-                    "hints": {
-                        "priority": 0
-                    }
-                },
-                {
-                    "name": "Time",
-                    "key": "utc",
-                    "format": "utc",
-                    "hints": {
-                        "domain": 2,
-                        "priority": 1
-                    },
-                    "source": "utc"
-                },
-                {
-                    "name": "Local Time",
-                    "key": "local",
-                    "format": "local-format",
-                    "hints": {
-                        "domain": 1,
-                        "priority": 2
-                    },
-                    "source": "local"
-                }
-            ]
-        }
-    };
-
-    // this setups up the app
-    beforeEach((done) => {
-        const appHolder = document.createElement('div');
-        appHolder.style.width = '640px';
-        appHolder.style.height = '480px';
-
-        openmct = createOpenMct();
-
-        parent = document.createElement('div');
-        child = document.createElement('div');
-        parent.appendChild(child);
-
-        spyOn(openmct.telemetry, 'request').and.returnValue(Promise.resolve([]));
-
-        imageryPlugin = new ImageryPlugin();
-        openmct.install(imageryPlugin);
-
-        spyOn(openmct.objects, 'get').and.returnValue(Promise.resolve({}));
-
-        openmct.time.timeSystem(timeFormat, {
-            start: 0,
-            end: 4
-        });
-
-        openmct.on('start', done);
-        openmct.startHeadless(appHolder);
-    });
-
-    afterEach(() => {
-        return resetApplicationState(openmct);
-    });
-
-    it("should provide an imagery view only for imagery producing objects", () => {
-        let applicableViews = openmct.objectViews.get(imageryObject);
-        let imageryView = applicableViews.find(
-            viewProvider => viewProvider.key === imageryKey
-        );
-
-        expect(imageryView).toBeDefined();
-    });
-
-    describe("imagery view", () => {
-        let applicableViews;
-        let imageryViewProvider;
-        let imageryView;
-
-        beforeEach(async (done) => {
-            let telemetryRequestResolve;
-            let telemetryRequestPromise = new Promise((resolve) => {
-                telemetryRequestResolve = resolve;
-            });
-
-            openmct.telemetry.request.and.callFake(() => {
-                telemetryRequestResolve(imageTelemetry);
-
-                return telemetryRequestPromise;
-            });
-
-            openmct.time.clock('local', {
-                start: bounds.start,
-                end: bounds.end + 100
-            });
-
-            applicableViews = openmct.objectViews.get(imageryObject);
-            imageryViewProvider = applicableViews.find(viewProvider => viewProvider.key === imageryKey);
-            imageryView = imageryViewProvider.view(imageryObject);
-            imageryView.show(child);
-
-            await telemetryRequestPromise;
-            await Vue.nextTick();
-
-            return done();
-        });
-
-        it("on mount should show the the most recent image", () => {
-            const imageInfo = getImageInfo(parent);
-
-            expect(imageInfo.url.indexOf(imageTelemetry[COUNT - 1].timeId)).not.toEqual(-1);
-        });
-
-        it("should show the clicked thumbnail as the main image", async () => {
-            const target = imageTelemetry[5].url;
-            parent.querySelectorAll(`img[src='${target}']`)[0].click();
-            await Vue.nextTick();
-            const imageInfo = getImageInfo(parent);
-
-            expect(imageInfo.url.indexOf(imageTelemetry[5].timeId)).not.toEqual(-1);
-        });
-
-        it("should show that an image is new", async (done) => {
-            await Vue.nextTick();
-
-            // used in code, need to wait to the 500ms here too
-            setTimeout(() => {
-                const imageIsNew = isNew(parent);
-
-                expect(imageIsNew).toBeTrue();
-                done();
-            }, REFRESH_CSS_MS);
-        });
-
-        it("should show that an image is not new", async (done) => {
-            const target = imageTelemetry[2].url;
-            parent.querySelectorAll(`img[src='${target}']`)[0].click();
-
-            await Vue.nextTick();
-
-            // used in code, need to wait to the 500ms here too
-            setTimeout(() => {
-                const imageIsNew = isNew(parent);
-
-                expect(imageIsNew).toBeFalse();
-                done();
-            }, REFRESH_CSS_MS);
-        });
-
-        it("should navigate via arrow keys", async () => {
-            let keyOpts = {
-                element: parent.querySelector('.c-imagery'),
-                key: 'ArrowLeft',
-                keyCode: 37,
-                type: 'keyup'
-            };
-
-            simulateKeyEvent(keyOpts);
-
-            await Vue.nextTick();
-
-            const imageInfo = getImageInfo(parent);
-
-            expect(imageInfo.url.indexOf(imageTelemetry[COUNT - 2].timeId)).not.toEqual(-1);
-        });
-
-        it("should navigate via numerous arrow keys", async () => {
-            let element = parent.querySelector('.c-imagery');
-            let type = 'keyup';
-            let leftKeyOpts = {
-                element,
-                type,
-                key: 'ArrowLeft',
-                keyCode: 37
-            };
-            let rightKeyOpts = {
-                element,
-                type,
-                key: 'ArrowRight',
-                keyCode: 39
-            };
-
-            // left thrice
-            simulateKeyEvent(leftKeyOpts);
-            simulateKeyEvent(leftKeyOpts);
-            simulateKeyEvent(leftKeyOpts);
-            // right once
-            simulateKeyEvent(rightKeyOpts);
-
-            await Vue.nextTick();
-
-            const imageInfo = getImageInfo(parent);
-
-            expect(imageInfo.url.indexOf(imageTelemetry[COUNT - 3].timeId)).not.toEqual(-1);
-        });
-
-    });
-});
--- a/src/plugins/interceptors/plugin.js
+++ b/src/plugins/interceptors/plugin.js
@@ -1,9 +0,0 @@
-import missingObjectInterceptor from "./missingObjectInterceptor";
-import myItemsInterceptor from "./myItemsInterceptor";
-
-export default function plugin() {
-    return function install(openmct) {
-        myItemsInterceptor(openmct);
-        missingObjectInterceptor(openmct);
-    };
-}
--- a/src/plugins/localTimeSystem/pluginSpec.js
+++ b/src/plugins/localTimeSystem/pluginSpec.js
@@ -1,114 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-
-import {
-    createOpenMct,
-    resetApplicationState
-} from 'utils/testing';
-
-describe("The local time", () => {
-    const LOCAL_FORMAT_KEY = 'local-format';
-    const LOCAL_SYSTEM_KEY = 'local';
-    const JUNK = "junk";
-    const TIMESTAMP = -14256000000;
-    const DATESTRING = '1969-07-20 12:00:00.000 am';
-    let openmct;
-
-    beforeEach((done) => {
-
-        openmct = createOpenMct();
-
-        openmct.install(openmct.plugins.LocalTimeSystem());
-
-        openmct.on('start', done);
-        openmct.startHeadless();
-
-    });
-
-    afterEach(() => {
-        return resetApplicationState(openmct);
-    });
-
-    describe("system", function () {
-
-        let localTimeSystem;
-
-        beforeEach(() => {
-            localTimeSystem = openmct.time.timeSystem(LOCAL_SYSTEM_KEY, {
-                start: 0,
-                end: 4
-            });
-        });
-
-        it("is installed", () => {
-            let timeSystems = openmct.time.getAllTimeSystems();
-            let local = timeSystems.find(ts => ts.key === LOCAL_SYSTEM_KEY);
-
-            expect(local).not.toEqual(-1);
-        });
-
-        it("can be set to be the main time system", () => {
-            expect(openmct.time.timeSystem().key).toBe(LOCAL_SYSTEM_KEY);
-        });
-
-        it("uses the local-format time format", () => {
-            expect(localTimeSystem.timeFormat).toBe(LOCAL_FORMAT_KEY);
-        });
-
-        it("is UTC based", () => {
-            expect(localTimeSystem.isUTCBased).toBe(true);
-        });
-
-        it("defines expected metadata", () => {
-            expect(localTimeSystem.key).toBe(LOCAL_SYSTEM_KEY);
-            expect(localTimeSystem.name).toBeDefined();
-            expect(localTimeSystem.cssClass).toBeDefined();
-            expect(localTimeSystem.durationFormat).toBeDefined();
-        });
-    });
-
-    describe("formatter can be obtained from the telemetry API and", () => {
-
-        let localTimeFormatter;
-        let dateString;
-        let timeStamp;
-
-        beforeEach(() => {
-            localTimeFormatter = openmct.telemetry.getFormatter(LOCAL_FORMAT_KEY);
-            dateString = localTimeFormatter.format(TIMESTAMP);
-            timeStamp = localTimeFormatter.parse(DATESTRING);
-        });
-
-        it("will format a timestamp in local time format", () => {
-            expect(localTimeFormatter.format(TIMESTAMP)).toBe(dateString);
-        });
-
-        it("will parse an local time Date String into milliseconds", () => {
-            expect(localTimeFormatter.parse(DATESTRING)).toBe(timeStamp);
-        });
-
-        it("will validate correctly", () => {
-            expect(localTimeFormatter.validate(DATESTRING)).toBe(true);
-            expect(localTimeFormatter.validate(JUNK)).toBe(false);
-        });
-    });
-});
--- a/src/plugins/move/MoveAction.js
+++ b/src/plugins/move/MoveAction.js
@@ -1,169 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-export default class MoveAction {
-    constructor(openmct) {
-        this.name = 'Move';
-        this.key = 'move';
-        this.description = 'Move this object from its containing object to another object.';
-        this.cssClass = "icon-move";
-        this.group = "action";
-        this.priority = 7;
-
-        this.openmct = openmct;
-    }
-
-    async invoke(objectPath) {
-        let object = objectPath[0];
-        let inNavigationPath = this.inNavigationPath(object);
-        let oldParent = objectPath[1];
-        let dialogService = this.openmct.$injector.get('dialogService');
-        let dialogForm = this.getDialogForm(object, oldParent);
-        let userInput = await dialogService.getUserInput(dialogForm, { name: object.name });
-
-        // if we need to update name
-        if (object.name !== userInput.name) {
-            this.openmct.objects.mutate(object, 'name', userInput.name);
-        }
-
-        let parentContext = userInput.location.getCapability('context');
-        let newParent = await this.openmct.objects.get(parentContext.domainObject.id);
-
-        if (inNavigationPath && this.openmct.editor.isEditing()) {
-            this.openmct.editor.save();
-        }
-
-        this.addToNewParent(object, newParent);
-        this.removeFromOldParent(oldParent, object);
-
-        if (inNavigationPath) {
-            let newObjectPath = await this.openmct.objects.getOriginalPath(object.identifier);
-            let root = await this.openmct.objects.getRoot();
-            let rootChildCount = root.composition.length;
-
-            // if not multiple root children, remove root from path
-            if (rootChildCount < 2) {
-                newObjectPath.pop(); // remove ROOT
-            }
-
-            this.navigateTo(newObjectPath);
-        }
-    }
-
-    inNavigationPath(object) {
-        return this.openmct.router.path
-            .some(objectInPath => this.openmct.objects.areIdsEqual(objectInPath.identifier, object.identifier));
-    }
-
-    navigateTo(objectPath) {
-        let urlPath = objectPath.reverse()
-            .map(object => this.openmct.objects.makeKeyString(object.identifier))
-            .join("/");
-
-        window.location.href = '#/browse/' + urlPath;
-    }
-
-    addToNewParent(child, newParent) {
-        let newParentKeyString = this.openmct.objects.makeKeyString(newParent.identifier);
-        let compositionCollection = this.openmct.composition.get(newParent);
-
-        this.openmct.objects.mutate(child, 'location', newParentKeyString);
-        compositionCollection.add(child);
-    }
-
-    removeFromOldParent(parent, child) {
-        let compositionCollection = this.openmct.composition.get(parent);
-
-        compositionCollection.remove(child);
-    }
-
-    getDialogForm(object, parent) {
-        return {
-            name: "Move Item",
-            sections: [
-                {
-                    rows: [
-                        {
-                            key: "name",
-                            control: "textfield",
-                            name: "Folder Name",
-                            pattern: "\\S+",
-                            required: true,
-                            cssClass: "l-input-lg"
-                        },
-                        {
-                            name: "location",
-                            control: "locator",
-                            validate: this.validate(object, parent),
-                            key: 'location'
-                        }
-                    ]
-                }
-            ]
-        };
-    }
-
-    validate(object, currentParent) {
-        return (parentCandidate) => {
-            let currentParentKeystring = this.openmct.objects.makeKeyString(currentParent.identifier);
-            let parentCandidateKeystring = this.openmct.objects.makeKeyString(parentCandidate.getId());
-            let objectKeystring = this.openmct.objects.makeKeyString(object.identifier);
-
-            if (!parentCandidateKeystring || !currentParentKeystring) {
-                return false;
-            }
-
-            if (parentCandidateKeystring === currentParentKeystring) {
-                return false;
-            }
-
-            if (parentCandidateKeystring === objectKeystring) {
-                return false;
-            }
-
-            if (parentCandidate.getModel().composition.indexOf(objectKeystring) !== -1) {
-                return false;
-            }
-
-            return this.openmct.composition.checkPolicy(
-                parentCandidate.useCapability('adapter'),
-                object
-            );
-        };
-    }
-
-    appliesTo(objectPath) {
-        let parent = objectPath[1];
-        let parentType = parent && this.openmct.types.get(parent.type);
-        let child = objectPath[0];
-        let childType = child && this.openmct.types.get(child.type);
-
-        if (child.locked || (parent && parent.locked)) {
-            return false;
-        }
-
-        return parentType
-            && parentType.definition.creatable
-            && childType
-            && childType.definition.creatable
-            && Array.isArray(parent.composition);
-    }
-}
--- a/src/plugins/move/plugin.js
+++ b/src/plugins/move/plugin.js
@@ -1,28 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-import MoveAction from "./MoveAction";
-
-export default function () {
-    return function (openmct) {
-        openmct.actions.register(new MoveAction(openmct));
-    };
-}
--- a/src/plugins/move/pluginSpec.js
+++ b/src/plugins/move/pluginSpec.js
@@ -1,110 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-import MoveActionPlugin from './plugin.js';
-import MoveAction from './MoveAction.js';
-import {
-    createOpenMct,
-    resetApplicationState,
-    getMockObjects
-} from 'utils/testing';
-
-describe("The Move Action plugin", () => {
-
-    let openmct;
-    let moveAction;
-    let childObject;
-    let parentObject;
-    let anotherParentObject;
-
-    // this setups up the app
-    beforeEach((done) => {
-        const appHolder = document.createElement('div');
-        appHolder.style.width = '640px';
-        appHolder.style.height = '480px';
-
-        openmct = createOpenMct();
-
-        childObject = getMockObjects({
-            objectKeyStrings: ['folder'],
-            overwrite: {
-                folder: {
-                    name: "Child Folder",
-                    identifier: {
-                        namespace: "",
-                        key: "child-folder-object"
-                    }
-                }
-            }
-        }).folder;
-        parentObject = getMockObjects({
-            objectKeyStrings: ['folder'],
-            overwrite: {
-                folder: {
-                    name: "Parent Folder",
-                    composition: [childObject.identifier]
-                }
-            }
-        }).folder;
-        anotherParentObject = getMockObjects({
-            objectKeyStrings: ['folder'],
-            overwrite: {
-                folder: {
-                    name: "Another Parent Folder"
-                }
-            }
-        }).folder;
-
-        // already installed by default, but never hurts, just adds to context menu
-        openmct.install(MoveActionPlugin());
-
-        openmct.on('start', done);
-        openmct.startHeadless(appHolder);
-    });
-
-    afterEach(() => {
-        resetApplicationState(openmct);
-    });
-
-    it("should be defined", () => {
-        expect(MoveActionPlugin).toBeDefined();
-    });
-
-    describe("when moving an object to a new parent and removing from the old parent", () => {
-
-        beforeEach(() => {
-            moveAction = new MoveAction(openmct);
-            moveAction.addToNewParent(childObject, anotherParentObject);
-            moveAction.removeFromOldParent(parentObject, childObject);
-        });
-
-        it("the child object's identifier should be in the new parent's composition", () => {
-            let newParentChild = anotherParentObject.composition[0];
-            expect(newParentChild).toEqual(childObject.identifier);
-        });
-
-        it("the child object's identifier should be removed from the old parent's composition", () => {
-            let oldParentComposition = parentObject.composition;
-            expect(oldParentComposition.length).toEqual(0);
-        });
-    });
-
-});
--- a/src/plugins/notebook/actions/CopyToNotebookAction.js
+++ b/src/plugins/notebook/actions/CopyToNotebookAction.js
@@ -6,11 +6,11 @@ export default class CopyToNotebookAction {
        this.openmct = openmct;

        this.cssClass = 'icon-duplicate';
-        this.description = 'Copy value to notebook as an entry';
+        this.description = 'Copy to Notebook action';
        this.group = "action";
        this.key = 'copyToNotebook';
        this.name = 'Copy to Notebook';
-        this.priority = 1;
+        this.priority = 9;
    }

    copyToNotebook(entryText) {
@@ -25,16 +25,15 @@ export default class CopyToNotebookAction {
            });
    }

-    invoke(objectPath, view = {}) {
-        let viewContext = view.getViewContext && view.getViewContext();
-
+    invoke(objectPath, viewContext) {
        this.copyToNotebook(viewContext.formattedValueForCopy());
    }

-    appliesTo(objectPath, view = {}) {
-        let viewContext = view.getViewContext && view.getViewContext();
+    appliesTo(objectPath, viewContext) {
+        if (viewContext && viewContext.getViewKey) {
+            return viewContext.getViewKey().includes('alphanumeric-format');
+        }

-        return viewContext && viewContext.formattedValueForCopy
-            && typeof viewContext.formattedValueForCopy === 'function';
+        return false;
    }
 }
--- a/src/plugins/notebook/components/Notebook.vue
+++ b/src/plugins/notebook/components/Notebook.vue
@@ -24,12 +24,12 @@
                 :default-section-id="defaultSectionId"
                 :domain-object="internalDomainObject"
                 :page-title="internalDomainObject.configuration.pageTitle"
+                 :pages="pages"
                 :section-title="internalDomainObject.configuration.sectionTitle"
                 :sections="sections"
-                 :selected-section="selectedSection"
                 :sidebar-covers-entries="sidebarCoversEntries"
-                 @pagesChanged="pagesChanged"
-                 @sectionsChanged="sectionsChanged"
+                 @updatePage="updatePage"
+                 @updateSection="updateSection"
                 @toggleNav="toggleNav"
        />
        <div class="c-notebook__page-view">
@@ -111,7 +111,7 @@ 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 { DEFAULT_CLASS, addNotebookEntry, createNewEmbed, getNotebookEntries } from '../utils/notebook-entries';
 import objectUtils from 'objectUtils';

 import { throttle } from 'lodash';
@@ -220,7 +220,7 @@ export default {
                return s;
            });

-            this.sectionsChanged({ sections });
+            this.updateSection({ sections });
            this.throttledSearchItem('');
        },
        createNotebookStorageObject() {
@@ -309,7 +309,7 @@ export default {
                return null;
            }

-            return this.openmct.objects.get(oldNotebookStorage.notebookMeta.identifier);
+            return this.openmct.objects.get(oldNotebookStorage.notebookMeta.identifier).then(d => d);
        },
        getPage(section, id) {
            return section.pages.find(p => p.id === id);
@@ -379,6 +379,9 @@ export default {

            return this.sections.find(section => section.isSelected);
        },
+        mutateObject(key, value) {
+            this.openmct.objects.mutate(this.internalDomainObject, key, value);
+        },
        navigateToSectionPage() {
            const { pageId, sectionId } = this.openmct.router.getParams();
            if (!pageId || !sectionId) {
@@ -395,7 +398,7 @@ export default {
                return s;
            });

-            this.sectionsChanged({ sections });
+            this.updateSection({ sections });
        },
        newEntry(embed = null) {
            this.search = '';
@@ -408,30 +411,19 @@ export default {
        orientationChange() {
            this.formatSidebar();
        },
-        pagesChanged({ pages = [], id = null}) {
-            const selectedSection = this.getSelectedSection();
-            if (!selectedSection) {
-                return;
-            }
-
-            selectedSection.pages = pages;
-            const sections = this.sections.map(section => {
-                if (section.id === selectedSection.id) {
-                    section = selectedSection;
-                }
-
-                return section;
-            });
-
-            this.sectionsChanged({ sections });
-            this.updateDefaultNotebookPage(pages, id);
-        },
        removeDefaultClass(domainObject) {
            if (!domainObject) {
                return;
            }

-            this.openmct.status.delete(domainObject.identifier);
+            const classList = domainObject.classList || [];
+            const index = classList.indexOf(DEFAULT_CLASS);
+            if (!classList.length || index < 0) {
+                return;
+            }
+
+            classList.splice(index, 1);
+            this.openmct.objects.mutate(domainObject, 'classList', classList);
        },
        searchItem(input) {
            this.search = input;
@@ -448,14 +440,12 @@ export default {
                setDefaultNotebook(this.openmct, notebookStorage);
            }

-            if (this.defaultSectionId && this.defaultSectionId.length === 0 || this.defaultSectionId !== notebookStorage.section.id) {
+            if (this.defaultSectionId.length === 0 || this.defaultSectionId !== notebookStorage.section.id) {
                this.defaultSectionId = notebookStorage.section.id;
-                setDefaultNotebookSection(notebookStorage.section);
            }

-            if (this.defaultPageId && this.defaultPageId.length === 0 || this.defaultPageId !== notebookStorage.page.id) {
+            if (this.defaultPageId.length === 0 || this.defaultPageId !== notebookStorage.page.id) {
                this.defaultPageId = notebookStorage.page.id;
-                setDefaultNotebookPage(notebookStorage.page);
            }
        },
        updateDefaultNotebookPage(pages, id) {
@@ -519,11 +509,29 @@ export default {
            const notebookEntries = configuration.entries || {};
            notebookEntries[this.selectedSection.id][this.selectedPage.id] = entries;

-            mutateObject(this.openmct, this.internalDomainObject, 'configuration.entries', notebookEntries);
+            this.mutateObject('configuration.entries', notebookEntries);
        },
        updateInternalDomainObject(domainObject) {
            this.internalDomainObject = domainObject;
        },
+        updatePage({ pages = [], id = null}) {
+            const selectedSection = this.getSelectedSection();
+            if (!selectedSection) {
+                return;
+            }
+
+            selectedSection.pages = pages;
+            const sections = this.sections.map(section => {
+                if (section.id === selectedSection.id) {
+                    section = selectedSection;
+                }
+
+                return section;
+            });
+
+            this.updateSection({ sections });
+            this.updateDefaultNotebookPage(pages, id);
+        },
        updateParams(sections) {
            const selectedSection = sections.find(s => s.isSelected);
            if (!selectedSection) {
@@ -547,8 +555,8 @@ export default {
                pageId
            });
        },
-        sectionsChanged({ sections, id = null }) {
-            mutateObject(this.openmct, this.internalDomainObject, 'configuration.sections', sections);
+        updateSection({ sections, id = null }) {
+            this.mutateObject('configuration.sections', sections);

            this.updateParams(sections);
            this.updateDefaultNotebookSection(sections, id);
--- a/src/plugins/notebook/components/NotebookEmbed.vue
+++ b/src/plugins/notebook/components/NotebookEmbed.vue
@@ -118,7 +118,7 @@ export default {
            painterroInstance.show(this.embed.snapshot.src);
        },
        changeLocation() {
-            const hash = this.embed.historicLink;
+            const link = this.embed.historicLink;

            const bounds = this.openmct.time.bounds();
            const isTimeBoundChanged = this.embed.bounds.start !== bounds.start
@@ -143,9 +143,8 @@ export default {
                this.openmct.notifications.alert(message);
            }

-            const relativeHash = hash.slice(hash.indexOf('#'));
-            const url = new URL(relativeHash, `${location.protocol}//${location.host}${location.pathname}`);
-            window.location.hash = url.hash;
+            const url = new URL(link);
+            window.location.href = url.hash;
        },
        formatTime(unixTime, timeFormat) {
            return Moment.utc(unixTime).format(timeFormat);
--- a/src/plugins/notebook/components/NotebookMenuSwitcher.vue
+++ b/src/plugins/notebook/components/NotebookMenuSwitcher.vue
@@ -17,7 +17,7 @@

 <script>
 import Snapshot from '../snapshot';
-import { getDefaultNotebook, validateNotebookStorageObject } from '../utils/notebook-storage';
+import { getDefaultNotebook } from '../utils/notebook-storage';
 import { NOTEBOOK_DEFAULT, NOTEBOOK_SNAPSHOT } from '../notebook-constants';

 export default {
@@ -49,10 +49,7 @@ export default {
        };
    },
    mounted() {
-        validateNotebookStorageObject();
-
        this.notebookSnapshot = new Snapshot(this.openmct);
-        this.setDefaultNotebookStatus();
    },
    methods: {
        showMenu(event) {
@@ -88,7 +85,7 @@ export default {

            this.openmct.menus.showMenu(x, y, notebookTypes);
        },
-        snapshot(notebookType) {
+        snapshot(notebook) {
            this.$nextTick(() => {
                const element = document.querySelector('.c-overlay__contents')
                    || document.getElementsByClassName('l-shell__main-container')[0];
@@ -106,17 +103,8 @@ export default {
                    openmct: this.openmct
                };

-                this.notebookSnapshot.capture(snapshotMeta, notebookType, element);
+                this.notebookSnapshot.capture(snapshotMeta, notebook.type, element);
            });
-        },
-        setDefaultNotebookStatus() {
-            let defaultNotebookObject = getDefaultNotebook();
-
-            if (defaultNotebookObject && defaultNotebookObject.notebookMeta) {
-                let notebookIdentifier = defaultNotebookObject.notebookMeta.identifier;
-
-                this.openmct.status.set(notebookIdentifier, 'notebook-default');
-            }
        }
    }
 };
--- a/src/plugins/notebook/components/PageCollection.vue
+++ b/src/plugins/notebook/components/PageCollection.vue
@@ -66,10 +66,14 @@ export default {
            }
        }
    },
+    data() {
+        return {
+        };
+    },
    methods: {
        deletePage(id) {
            const selectedSection = this.sections.find(s => s.isSelected);
-            const page = this.pages.find(p => p.id !== id);
+            const page = this.pages.filter(p => p.id !== id);
            deleteNotebookEntries(this.openmct, this.domainObject, selectedSection, page);

            const selectedPage = this.pages.find(p => p.isSelected);
--- a/src/plugins/notebook/components/SectionCollection.vue
+++ b/src/plugins/notebook/components/SectionCollection.vue
@@ -53,6 +53,10 @@ export default {
            }
        }
    },
+    data() {
+        return {
+        };
+    },
    methods: {
        deleteSection(id) {
            const section = this.sections.find(s => s.id === id);
--- a/src/plugins/notebook/components/Sidebar.vue
+++ b/src/plugins/notebook/components/Sidebar.vue
@@ -18,7 +18,7 @@
                               :domain-object="domainObject"
                               :sections="sections"
                               :section-title="sectionTitle"
-                               @updateSection="sectionsChanged"
+                               @updateSection="updateSection"
            />
        </div>
    </div>
@@ -48,7 +48,7 @@
                            :sidebar-covers-entries="sidebarCoversEntries"
                            :page-title="pageTitle"
                            @toggleNav="toggleNav"
-                            @updatePage="pagesChanged"
+                            @updatePage="updatePage"
            />
        </div>
    </div>
@@ -85,6 +85,13 @@ export default {
                return {};
            }
        },
+        pages: {
+            type: Array,
+            required: true,
+            default() {
+                return [];
+            }
+        },
        pageTitle: {
            type: String,
            default() {
@@ -115,16 +122,9 @@ export default {
        return {
        };
    },
-    computed: {
-        pages() {
-            const selectedSection = this.sections.find(section => section.isSelected);
-
-            return selectedSection && selectedSection.pages || [];
-        }
-    },
    watch: {
-        pages(newPages) {
-            if (!newPages.length) {
+        pages(newpages) {
+            if (!newpages.length) {
                this.addPage();
            }
        },
@@ -141,79 +141,55 @@ export default {
    },
    methods: {
        addPage() {
-            const newPage = this.createNewPage();
-            const pages = this.addNewPage(newPage);
-
-            this.pagesChanged({
-                pages,
-                id: newPage.id
-            });
-        },
-        addSection() {
-            const newSection = this.createNewSection();
-            const sections = this.addNewSection(newSection);
-
-            this.sectionsChanged({
-                sections,
-                id: newSection.id
-            });
-        },
-        addNewPage(page) {
-            const pages = this.pages.map(p => {
-                p.isSelected = false;
-
-                return p;
-            });
-
-            return pages.concat(page);
-        },
-        addNewSection(section) {
-            const sections = this.sections.map(s => {
-                s.isSelected = false;
-
-                return s;
-            });
-
-            return sections.concat(section);
-        },
-        createNewPage() {
            const pageTitle = this.pageTitle;
            const id = uuid();
-
-            return {
+            const page = {
                id,
                isDefault: false,
                isSelected: true,
                name: `Unnamed ${pageTitle}`,
                pageTitle
            };
-        },
-        createNewSection() {
-            const sectionTitle = this.sectionTitle;
-            const id = uuid();
-            const page = this.createNewPage();
-            const pages = [page];

-            return {
-                id,
-                isDefault: false,
-                isSelected: true,
-                name: `Unnamed ${sectionTitle}`,
-                pages,
-                sectionTitle
-            };
-        },
-        toggleNav() {
-            this.$emit('toggleNav');
-        },
-        pagesChanged({ pages, id }) {
-            this.$emit('pagesChanged', {
+            this.pages.forEach(p => p.isSelected = false);
+            const pages = this.pages.concat(page);
+
+            this.updatePage({
                pages,
                id
            });
        },
-        sectionsChanged({ sections, id }) {
-            this.$emit('sectionsChanged', {
+        addSection() {
+            const sectionTitle = this.sectionTitle;
+            const id = uuid();
+            const section = {
+                id,
+                isDefault: false,
+                isSelected: true,
+                name: `Unnamed ${sectionTitle}`,
+                pages: [],
+                sectionTitle
+            };
+
+            this.sections.forEach(s => s.isSelected = false);
+            const sections = this.sections.concat(section);
+
+            this.updateSection({
+                sections,
+                id
+            });
+        },
+        toggleNav() {
+            this.$emit('toggleNav');
+        },
+        updatePage({ pages, id }) {
+            this.$emit('updatePage', {
+                pages,
+                id
+            });
+        },
+        updateSection({ sections, id }) {
+            this.$emit('updateSection', {
                sections,
                id
            });
--- a/src/plugins/notebook/pluginSpec.js
+++ b/src/plugins/notebook/pluginSpec.js
@@ -20,7 +20,7 @@
 * at runtime from the About dialog for additional information.
 *****************************************************************************/

-import { createOpenMct, createMouseEvent, resetApplicationState } from 'utils/testing';
+import { createOpenMct, resetApplicationState } from 'utils/testing';
 import NotebookPlugin from './plugin';
 import Vue from 'vue';

@@ -133,89 +133,4 @@ describe("Notebook plugin:", () => {
            expect(hasMajorElements).toBe(true);
        });
    });
-
-    describe("Notebook Snapshots view:", () => {
-        let snapshotIndicator;
-        let drawerElement;
-
-        function clickSnapshotIndicator() {
-            const indicator = element.querySelector('.icon-camera');
-            const button = indicator.querySelector('button');
-            const clickEvent = createMouseEvent('click');
-
-            button.dispatchEvent(clickEvent);
-        }
-
-        beforeAll(() => {
-            snapshotIndicator = openmct.indicators.indicatorObjects
-                .find(indicator => indicator.key === 'notebook-snapshot-indicator').element;
-
-            element.append(snapshotIndicator);
-
-            return Vue.nextTick();
-        });
-
-        afterAll(() => {
-            snapshotIndicator.remove();
-            snapshotIndicator = undefined;
-
-            if (drawerElement) {
-                drawerElement.remove();
-                drawerElement = undefined;
-            }
-        });
-
-        beforeEach(() => {
-            drawerElement = document.querySelector('.l-shell__drawer');
-        });
-
-        afterEach(() => {
-            if (drawerElement) {
-                drawerElement.classList.remove('is-expanded');
-            }
-        });
-
-        it("has Snapshots indicator", () => {
-            const hasSnapshotIndicator = snapshotIndicator !== null && snapshotIndicator !== undefined;
-            expect(hasSnapshotIndicator).toBe(true);
-        });
-
-        it("snapshots container has class isExpanded", () => {
-            let classes = drawerElement.classList;
-            const isExpandedBefore = classes.contains('is-expanded');
-
-            clickSnapshotIndicator();
-            classes = drawerElement.classList;
-            const isExpandedAfterFirstClick = classes.contains('is-expanded');
-
-            expect(isExpandedBefore).toBeFalse();
-            expect(isExpandedAfterFirstClick).toBeTrue();
-        });
-
-        it("snapshots container does not have class isExpanded", () => {
-            let classes = drawerElement.classList;
-            const isExpandedBefore = classes.contains('is-expanded');
-
-            clickSnapshotIndicator();
-            classes = drawerElement.classList;
-            const isExpandedAfterFirstClick = classes.contains('is-expanded');
-
-            clickSnapshotIndicator();
-            classes = drawerElement.classList;
-            const isExpandedAfterSecondClick = classes.contains('is-expanded');
-
-            expect(isExpandedBefore).toBeFalse();
-            expect(isExpandedAfterFirstClick).toBeTrue();
-            expect(isExpandedAfterSecondClick).toBeFalse();
-        });
-
-        it("show notebook snapshots container text", () => {
-            clickSnapshotIndicator();
-
-            const notebookSnapshots = drawerElement.querySelector('.l-browse-bar__object-name');
-            const snapshotsText = notebookSnapshots.textContent.trim();
-
-            expect(snapshotsText).toBe('Notebook Snapshots');
-        });
-    });
 });
--- a/src/plugins/notebook/snapshot.js
+++ b/src/plugins/notebook/snapshot.js
@@ -7,14 +7,15 @@ export default class Snapshot {
    constructor(openmct) {
        this.openmct = openmct;
        this.snapshotContainer = new SnapshotContainer(openmct);
+        this.exportImageService = openmct.$injector.get('exportImageService');
+        this.dialogService = openmct.$injector.get('dialogService');

        this.capture = this.capture.bind(this);
        this._saveSnapShot = this._saveSnapShot.bind(this);
    }

    capture(snapshotMeta, notebookType, domElement) {
-        const exportImageService = this.openmct.$injector.get('exportImageService');
-        exportImageService.exportPNGtoSRC(domElement, 's-status-taking-snapshot')
+        this.exportImageService.exportPNGtoSRC(domElement, 's-status-taking-snapshot')
            .then(function (blob) {
                const reader = new window.FileReader();
                reader.readAsDataURL(blob);
--- a/src/plugins/notebook/utils/notebook-entries.js
+++ b/src/plugins/notebook/utils/notebook-entries.js
@@ -1,6 +1,6 @@
 import objectLink from '../../../ui/mixins/object-link';

-export const DEFAULT_CLASS = 'notebook-default';
+export const DEFAULT_CLASS = 'is-notebook-default';
 const TIME_BOUNDS = {
    START_BOUND: 'tc.startBound',
    END_BOUND: 'tc.endBound',
@@ -8,29 +8,6 @@ const TIME_BOUNDS = {
    END_DELTA: 'tc.endDelta'
 };

-export function addEntryIntoPage(notebookStorage, entries, entry) {
-    const defaultSection = notebookStorage.section;
-    const defaultPage = notebookStorage.page;
-    if (!defaultSection || !defaultPage) {
-        return;
-    }
-
-    const newEntries = JSON.parse(JSON.stringify(entries));
-    let section = newEntries[defaultSection.id];
-    if (!section) {
-        newEntries[defaultSection.id] = {};
-    }
-
-    let page = newEntries[defaultSection.id][defaultPage.id];
-    if (!page) {
-        newEntries[defaultSection.id][defaultPage.id] = [];
-    }
-
-    newEntries[defaultSection.id][defaultPage.id].push(entry);
-
-    return newEntries;
-}
-
 export function getHistoricLinkInFixedMode(openmct, bounds, historicLink) {
    if (historicLink.includes('tc.mode=fixed')) {
        return historicLink;
@@ -61,6 +38,35 @@ export function getHistoricLinkInFixedMode(openmct, bounds, historicLink) {
    return params.join('&');
 }

+export function getNotebookDefaultEntries(notebookStorage, domainObject) {
+    if (!notebookStorage || !domainObject) {
+        return null;
+    }
+
+    const defaultSection = notebookStorage.section;
+    const defaultPage = notebookStorage.page;
+    if (!defaultSection || !defaultPage) {
+        return null;
+    }
+
+    const configuration = domainObject.configuration;
+    const entries = configuration.entries || {};
+
+    let section = entries[defaultSection.id];
+    if (!section) {
+        section = {};
+        entries[defaultSection.id] = section;
+    }
+
+    let page = entries[defaultSection.id][defaultPage.id];
+    if (!page) {
+        page = [];
+        entries[defaultSection.id][defaultPage.id] = [];
+    }
+
+    return entries[defaultSection.id][defaultPage.id];
+}
+
 export function createNewEmbed(snapshotMeta, snapshot = '') {
    const {
        bounds,
@@ -114,25 +120,24 @@ export function addNotebookEntry(openmct, domainObject, notebookStorage, embed =
        ? [embed]
        : [];

+    const defaultEntries = getNotebookDefaultEntries(notebookStorage, domainObject);
    const id = `entry-${date}`;
-    const entry = {
+    defaultEntries.push({
        id,
        createdOn: date,
        text: entryText,
        embeds
-    };
+    });

-    const newEntries = addEntryIntoPage(notebookStorage, entries, entry);
-
-    addDefaultClass(domainObject, openmct);
-    openmct.objects.mutate(domainObject, 'configuration.entries', newEntries);
+    addDefaultClass(domainObject);
+    openmct.objects.mutate(domainObject, 'configuration.entries', entries);

    return id;
 }

 export function getNotebookEntries(domainObject, selectedSection, selectedPage) {
    if (!domainObject || !selectedSection || !selectedPage) {
-        return;
+        return null;
    }

    const configuration = domainObject.configuration;
@@ -140,12 +145,12 @@ export function getNotebookEntries(domainObject, selectedSection, selectedPage)

    let section = entries[selectedSection.id];
    if (!section) {
-        return;
+        return null;
    }

    let page = entries[selectedSection.id][selectedPage.id];
    if (!page) {
-        return;
+        return null;
    }

    return entries[selectedSection.id][selectedPage.id];
@@ -191,13 +196,14 @@ export function deleteNotebookEntries(openmct, domainObject, selectedSection, se

    delete entries[selectedSection.id][selectedPage.id];

-    mutateObject(openmct, domainObject, 'configuration.entries', entries);
+    openmct.objects.mutate(domainObject, 'configuration.entries', entries);
 }

-export function mutateObject(openmct, object, key, value) {
-    openmct.objects.mutate(object, key, value);
-}
+function addDefaultClass(domainObject) {
+    const classList = domainObject.classList || [];
+    if (classList.includes(DEFAULT_CLASS)) {
+        return;
+    }

-function addDefaultClass(domainObject, openmct) {
-    openmct.status.set(domainObject.identifier, DEFAULT_CLASS);
+    classList.push(DEFAULT_CLASS);
 }
--- a/src/plugins/notebook/utils/notebook-entriesSpec.js
+++ b/src/plugins/notebook/utils/notebook-entriesSpec.js
@@ -20,7 +20,7 @@
 * at runtime from the About dialog for additional information.
 *****************************************************************************/
 import * as NotebookEntries from './notebook-entries';
-import { createOpenMct, resetApplicationState } from 'utils/testing';
+import { createOpenMct, spyOnBuiltins, resetApplicationState } from 'utils/testing';

 const notebookStorage = {
    domainObject: {
@@ -121,6 +121,7 @@ describe('Notebook Entries:', () => {
    beforeEach(done => {
        openmct = createOpenMct();
        window.localStorage.setItem('notebook-storage', null);
+        spyOnBuiltins(['mutate'], openmct.objects);

        done();
    });
@@ -136,16 +137,24 @@ describe('Notebook Entries:', () => {
        expect(entries.length).toEqual(0);
    });

-    it('addNotebookEntry adds entry', (done) => {
-        const unlisten = openmct.objects.observe(notebookDomainObject, '*', (object) => {
-            const entries = NotebookEntries.getNotebookEntries(notebookDomainObject, selectedSection, selectedPage);
-
-            expect(entries.length).toEqual(1);
-            done();
-            unlisten();
-        });
-
+    it('addNotebookEntry mutates object', () => {
        NotebookEntries.addNotebookEntry(openmct, notebookDomainObject, notebookStorage);
+
+        expect(openmct.objects.mutate).toHaveBeenCalled();
+    });
+
+    it('addNotebookEntry adds entry', () => {
+        NotebookEntries.addNotebookEntry(openmct, notebookDomainObject, notebookStorage);
+        const entries = NotebookEntries.getNotebookEntries(notebookDomainObject, selectedSection, selectedPage);
+
+        expect(entries.length).toEqual(1);
+    });
+
+    it('getEntryPosById returns valid position', () => {
+        const entryId = NotebookEntries.addNotebookEntry(openmct, notebookDomainObject, notebookStorage);
+        const position = NotebookEntries.getEntryPosById(entryId, notebookDomainObject, selectedSection, selectedPage);
+
+        expect(position).toEqual(0);
    });

    it('getEntryPosById returns valid position', () => {
@@ -165,13 +174,22 @@ describe('Notebook Entries:', () => {
        expect(success).toBe(true);
    });

-    it('deleteNotebookEntries deletes correct page entries', () => {
+    it('deleteNotebookEntries mutates object', () => {
+        openmct.objects.mutate.calls.reset();
+
+        NotebookEntries.addNotebookEntry(openmct, notebookDomainObject, notebookStorage);
+        NotebookEntries.deleteNotebookEntries(openmct, notebookDomainObject, selectedSection, selectedPage);
+
+        expect(openmct.objects.mutate).toHaveBeenCalledTimes(2);
+    });
+
+    it('deleteNotebookEntries deletes correct entry', () => {
        NotebookEntries.addNotebookEntry(openmct, notebookDomainObject, notebookStorage);
        NotebookEntries.addNotebookEntry(openmct, notebookDomainObject, notebookStorage);

        NotebookEntries.deleteNotebookEntries(openmct, notebookDomainObject, selectedSection, selectedPage);
        const afterEntries = NotebookEntries.getNotebookEntries(notebookDomainObject, selectedSection, selectedPage);

-        expect(afterEntries).toEqual(undefined);
+        expect(afterEntries).toEqual(null);
    });
 });
--- a/src/plugins/notebook/utils/notebook-storage.js
+++ b/src/plugins/notebook/utils/notebook-storage.js
@@ -67,24 +67,3 @@ export function setDefaultNotebookPage(page) {
    notebookStorage.page = page;
    saveDefaultNotebook(notebookStorage);
 }
-
-export function validateNotebookStorageObject() {
-    const notebookStorage = getDefaultNotebook();
-
-    let valid = false;
-    if (notebookStorage) {
-        Object.entries(notebookStorage).forEach(([key, value]) => {
-            const validKey = key !== undefined && key !== null;
-            const validValue = value !== undefined && value !== null;
-            valid = validKey && validValue;
-        });
-    }
-
-    if (valid) {
-        return notebookStorage;
-    }
-
-    console.warn('Invalid Notebook object, clearing default notebook storage');
-
-    clearDefaultNotebook();
-}
--- a/src/plugins/persistence/couch/CouchObjectProvider.js
+++ b/src/plugins/persistence/couch/CouchObjectProvider.js
@@ -87,8 +87,7 @@ export default class CouchObjectProvider {
            }

            //Sometimes CouchDB returns the old rev which fetching the object if there is a document update in progress
-            //Only update the rev if it's the first time we're getting the object from CouchDB. Subsequent revs should only be updated by updates.
-            if (!this.objectQueue[key].pending && !this.objectQueue[key].rev) {
+            if (!this.objectQueue[key].pending) {
                this.objectQueue[key].updateRevision(response[REV]);
            }

--- a/src/plugins/plot/res/templates/mct-plot.html
+++ b/src/plugins/plot/res/templates/mct-plot.html
@@ -40,7 +40,7 @@
                <div class="c-state-indicator__alert-cursor-lock icon-cursor-lock" title="Cursor is point locked. Click anywhere in the plot to unlock."></div>
                <div class="plot-legend-item"
                     ng-class="{
-                        'is-status--missing': series.domainObject.status === 'missing'
+                        'is-missing': series.domainObject.status === 'missing'
                    }"
                     ng-repeat="series in series track by $index"
                >
@@ -48,7 +48,7 @@
                        <span class="plot-series-color-swatch"
                              ng-style="{ 'background-color': series.get('color').asHexString() }">
                        </span>
-                        <span class="is-status__indicator" title="This item is missing or suspect"></span>
+                        <span class="is-missing__indicator" title="This item is missing"></span>
                        <span class="plot-series-name">{{ series.nameWithUnit() }}</span>
                    </div>
                    <div class="plot-series-value hover-value-enabled value-to-display-{{ legend.get('valueToShowWhenCollapsed') }} {{ series.closest.mctLimitState.cssClass }}"
@@ -95,14 +95,14 @@
                    <tr ng-repeat="series in series"
                        class="plot-legend-item"
                        ng-class="{
-                            'is-status--missing': series.domainObject.status === 'missing'
+                            'is-missing': series.domainObject.status === 'missing'
                        }"
                    >
                        <td class="plot-series-swatch-and-name">
                            <span class="plot-series-color-swatch"
                                  ng-style="{ 'background-color': series.get('color').asHexString() }">
                            </span>
-                            <span class="is-status__indicator" title="This item is missing or suspect"></span>
+                            <span class="is-missing__indicator" title="This item is missing"></span>
                            <span class="plot-series-name">{{ series.get('name') }}</span>
                        </td>

--- a/src/plugins/plot/src/configuration/YAxisModel.js
+++ b/src/plugins/plot/src/configuration/YAxisModel.js
@@ -171,7 +171,6 @@ define([
         * Update yAxis format, values, and label from known series.
         */
        updateFromSeries: function (series) {
-            this.unset('displayRange');
            const plotModel = this.plot.get('domainObject');
            const label = _.get(plotModel, 'configuration.yAxis.label');
            const sampleSeries = series.first();
--- a/src/plugins/plot/src/services/ExportImageService.js
+++ b/src/plugins/plot/src/services/ExportImageService.js
@@ -117,10 +117,8 @@ define(
         * @returns {promise}
         */
        ExportImageService.prototype.exportJPG = function (element, filename, className) {
-            const processedFilename = replaceDotsWithUnderscores(filename);
-
            return this.renderElement(element, "jpg", className).then(function (img) {
-                saveAs(img, processedFilename);
+                saveAs(img, filename);
            });
        };

@@ -132,10 +130,8 @@ define(
         * @returns {promise}
         */
        ExportImageService.prototype.exportPNG = function (element, filename, className) {
-            const processedFilename = replaceDotsWithUnderscores(filename);
-
            return this.renderElement(element, "png", className).then(function (img) {
-                saveAs(img, processedFilename);
+                saveAs(img, filename);
            });
        };

@@ -150,12 +146,6 @@ define(
            return this.renderElement(element, "png", className);
        };

-        function replaceDotsWithUnderscores(filename) {
-            const regex = /\./gi;
-
-            return filename.replace(regex, '_');
-        }
-
        /**
         * canvas.toBlob() not supported in IE < 10, Opera, and Safari. This polyfill
         * implements the method in browsers that would not otherwise support it.
--- a/src/plugins/plot/src/telemetry/StackedPlotController.js
+++ b/src/plugins/plot/src/telemetry/StackedPlotController.js
@@ -39,11 +39,10 @@ define([], function () {
            const thisRequest = {
                pending: 0
            };
-            const telemetryObjects = $scope.telemetryObjects = [];
-            const thisTickWidthMap = {};
-
            currentRequest = thisRequest;
            $scope.currentRequest = thisRequest;
+            const telemetryObjects = $scope.telemetryObjects = [];
+            const thisTickWidthMap = {};
            tickWidthMap = thisTickWidthMap;

            if (unlisten) {
@@ -53,10 +52,14 @@ define([], function () {

            function addChild(child) {
                const id = openmct.objects.makeKeyString(child.identifier);
-                const legacyObject = openmct.legacyObject(child);
-
                thisTickWidthMap[id] = 0;
-                telemetryObjects.push(legacyObject);
+                thisRequest.pending += 1;
+                objectService.getObjects([id])
+                    .then(function (objects) {
+                        thisRequest.pending -= 1;
+                        const childObj = objects[id];
+                        telemetryObjects.push(childObj);
+                    });
            }

            function removeChild(childIdentifier) {
@@ -81,7 +84,6 @@ define([], function () {
            }

            thisRequest.pending += 1;
-
            openmct.objects.get(domainObject.getId())
                .then(function (obj) {
                    thisRequest.pending -= 1;
--- a/src/plugins/plugins.js
+++ b/src/plugins/plugins.js
@@ -59,8 +59,7 @@ define([
    './persistence/couch/plugin',
    './defaultRootName/plugin',
    './timeline/plugin',
-    './viewDatumAction/plugin',
-    './interceptors/plugin'
+    './viewDatumAction/plugin'
 ], function (
    _,
    UTCTimeSystem,
@@ -100,8 +99,7 @@ define([
    CouchDBPlugin,
    DefaultRootName,
    Timeline,
-    ViewDatumAction,
-    ObjectInterceptors
+    ViewDatumAction
 ) {
    const bundleMap = {
        LocalStorage: 'platform/persistence/local',
@@ -196,7 +194,6 @@ define([
    plugins.DefaultRootName = DefaultRootName.default;
    plugins.Timeline = Timeline.default;
    plugins.ViewDatumAction = ViewDatumAction.default;
-    plugins.ObjectInterceptors = ObjectInterceptors.default;

    return plugins;
 });
--- a/src/plugins/tabs/components/tabs.vue
+++ b/src/plugins/tabs/components/tabs.vue
@@ -20,8 +20,8 @@
            Drag objects here to add them to this view.
        </div>
        <div
-            v-for="(tab, index) in tabsList"
-            :key="tab.keyString"
+            v-for="(tab,index) in tabsList"
+            :key="index"
            class="c-tab c-tabs-view__tab"
            :class="{
                'is-current': isCurrent(tab)
@@ -29,13 +29,13 @@
            @click="showTab(tab, index)"
        >
            <div class="c-tabs-view__tab__label c-object-label"
-                 :class="[tab.status ? `is-status--${tab.status}` : '']"
+                 :class="{'is-missing': tab.domainObject.status === 'missing'}"
            >
                <div class="c-object-label__type-icon"
                     :class="tab.type.definition.cssClass"
                >
-                    <span class="is-status__indicator"
-                          :title="`This item is ${tab.status}`"
+                    <span class="is-missing__indicator"
+                          title="This item is missing"
                    ></span>
                </div>
                <span class="c-button__label c-object-label__name">{{ tab.domainObject.name }}</span>
@@ -47,8 +47,8 @@
        </div>
    </div>
    <div
-        v-for="tab in tabsList"
-        :key="tab.keyString"
+        v-for="(tab, index) in tabsList"
+        :key="index"
        class="c-tabs-view__object-holder"
        :class="{'c-tabs-view__object-holder--hidden': !isCurrent(tab)}"
    >
@@ -56,7 +56,6 @@
            v-if="internalDomainObject.keep_alive ? currentTab : isCurrent(tab)"
            class="c-tabs-view__object"
            :object="tab.domainObject"
-            :object-path="tab.objectPath"
        />
    </div>
 </div>
@@ -79,7 +78,7 @@ const unknownObjectType = {
 };

 export default {
-    inject: ['openmct', 'domainObject', 'composition', 'objectPath'],
+    inject: ['openmct', 'domainObject', 'composition'],
    components: {
        ObjectView
    },
@@ -140,10 +139,6 @@ export default {
        this.composition.off('remove', this.removeItem);
        this.composition.off('reorder', this.onReorder);

-        this.tabsList.forEach(tab => {
-            tab.statusUnsubscribe();
-        });
-
        this.unsubscribe();
        this.clearCurrentTabIndexFromURL();

@@ -197,19 +192,10 @@ export default {
        },
        addItem(domainObject) {
            let type = this.openmct.types.get(domainObject.type) || unknownObjectType;
-            let keyString = this.openmct.objects.makeKeyString(domainObject.identifier);
-            let status = this.openmct.status.get(domainObject.identifier);
-            let statusUnsubscribe = this.openmct.status.observe(keyString, (updatedStatus) => {
-                this.updateStatus(keyString, updatedStatus);
-            });
-            let objectPath = [domainObject].concat(this.objectPath.slice());
            let tabItem = {
                domainObject,
-                status,
-                statusUnsubscribe,
-                objectPath,
-                type,
-                keyString
+                type: type,
+                key: this.openmct.objects.makeKeyString(domainObject.identifier)
            };

            this.tabsList.push(tabItem);
@@ -225,12 +211,10 @@ export default {
        },
        removeItem(identifier) {
            let pos = this.tabsList.findIndex(tab =>
-                tab.domainObject.identifier.namespace === identifier.namespace && tab.domainObject.identifier.keyString === identifier.keyString
+                tab.domainObject.identifier.namespace === identifier.namespace && tab.domainObject.identifier.key === identifier.key
            );
            let tabToBeRemoved = this.tabsList[pos];

-            tabToBeRemoved.statusUnsubscribe();
-
            this.tabsList.splice(pos, 1);

            if (this.isCurrent(tabToBeRemoved)) {
@@ -268,7 +252,7 @@ export default {
            this.allowDrop = false;
        },
        isCurrent(tab) {
-            return this.currentTab.keyString === tab.keyString;
+            return this.currentTab.key === tab.key;
        },
        updateInternalDomainObject(domainObject) {
            this.internalDomainObject = domainObject;
@@ -286,16 +270,6 @@ export default {
        },
        clearCurrentTabIndexFromURL() {
            deleteSearchParam(this.searchTabKey);
-        },
-        updateStatus(keyString, status) {
-            let tabPos = this.tabsList.findIndex((tab) => {
-                return tab.keyString === keyString;
-            });
-
-            if (tabPos !== -1) {
-                let tab = this.tabsList[tabPos];
-                this.$set(tab, 'status', status);
-            }
        }
    }
 };
--- a/src/plugins/tabs/tabs.js
+++ b/src/plugins/tabs/tabs.js
@@ -38,7 +38,7 @@ define([
            canEdit: function (domainObject) {
                return domainObject.type === 'tabs';
            },
-            view: function (domainObject, objectPath) {
+            view: function (domainObject) {
                let component;

                return {
@@ -56,7 +56,6 @@ define([
                            provide: {
                                openmct,
                                domainObject,
-                                objectPath,
                                composition: openmct.composition.get(domainObject)
                            },
                            template: '<tabs-component :isEditing="isEditing"></tabs-component>'
--- a/src/plugins/telemetryTable/ViewActions.js
+++ b/src/plugins/telemetryTable/ViewActions.js
@@ -30,13 +30,13 @@ let exportCSV = {
    },
    group: 'view'
 };
-let exportMarkedDataAsCSV = {
+let exportMarkedRows = {
    name: 'Export Marked Rows',
    key: 'export-csv-marked',
    description: "Export marked rows as CSV",
    cssClass: 'icon-download labeled',
    invoke: (objectPath, viewProvider) => {
-        viewProvider.getViewContext().exportMarkedDataAsCSV();
+        viewProvider.getViewContext().exportMarkedRows();
    },
    group: 'view'
 };
@@ -98,7 +98,7 @@ let autosizeColumns = {

 let viewActions = [
    exportCSV,
-    exportMarkedDataAsCSV,
+    exportMarkedRows,
    unmarkAllRows,
    pause,
    play,
--- a/src/plugins/telemetryTable/components/table-row.vue
+++ b/src/plugins/telemetryTable/components/table-row.vue
@@ -108,7 +108,8 @@ export default {
                    return {
                        viewHistoricalData: true,
                        viewDatumAction: true,
-                        getDatum: this.getDatum
+                        getDatum: this.getDatum,
+                        skipCache: true
                    };
                }
            }
@@ -191,8 +192,7 @@ export default {
                let contextualObjectPath = this.objectPath.slice();
                contextualObjectPath.unshift(domainObject);

-                let actionsCollection = this.openmct.actions.get(contextualObjectPath, this.actionsViewContext);
-                let allActions = actionsCollection.getActionsObject();
+                let allActions = this.openmct.actions.get(contextualObjectPath, this.actionsViewContext);
                let applicableActions = this.row.getContextMenuActions().map(key => allActions[key]);

                if (applicableActions.length) {
--- a/src/plugins/telemetryTable/components/table.vue
+++ b/src/plugins/telemetryTable/components/table.vue
@@ -960,7 +960,7 @@ export default {
            return {
                type: 'telemetry-table',
                exportAllDataAsCSV: this.exportAllDataAsCSV,
-                exportMarkedDataAsCSV: this.exportMarkedDataAsCSV,
+                exportMarkedRows: this.exportMarkedRows,
                unmarkAllRows: this.unmarkAllRows,
                togglePauseByButton: this.togglePauseByButton,
                expandColumns: this.recalculateColumnWidths,
--- a/src/plugins/timeline/Plan.vue
+++ b/src/plugins/timeline/Plan.vue
@@ -61,21 +61,13 @@ export default {
        this.openmct.time.on("timeSystem", this.setScaleAndPlotActivities);
        this.openmct.time.on("bounds", this.updateViewBounds);
        this.resizeTimer = setInterval(this.resize, RESIZE_POLL_INTERVAL);
-        this.unlisten = this.openmct.objects.observe(this.domainObject, '*', this.observeForChanges);
    },
    destroyed() {
        clearInterval(this.resizeTimer);
        this.openmct.time.off("timeSystem", this.setScaleAndPlotActivities);
        this.openmct.time.off("bounds", this.updateViewBounds);
-        if (this.unlisten) {
-            this.unlisten();
-        }
    },
    methods: {
-        observeForChanges(mutatedObject) {
-            this.validateJSON(mutatedObject.selectFile.body);
-            this.setScaleAndPlotActivities();
-        },
        resize() {
            if (this.$refs.axisHolder.clientWidth !== this.width) {
                this.setDimensions();
@@ -208,7 +200,7 @@ export default {
            return 0;
        },
        // Get the row where the next activity will land.
-        getRowForActivity(rectX, width, minimumActivityRow = 0) {
+        getRowForActivity(rectX, width, defaultActivityRow = 0) {
            let currentRow;
            let sortedActivityRows = Object.keys(this.activitiesByRow).sort(this.sortFn);

@@ -224,18 +216,17 @@ export default {

            for (let i = 0; i < sortedActivityRows.length; i++) {
                let row = sortedActivityRows[i];
-                if (row >= minimumActivityRow && getOverlap(this.activitiesByRow[row])) {
+                if (getOverlap(this.activitiesByRow[row])) {
                    currentRow = row;
                    break;
                }
            }

            if (currentRow === undefined && sortedActivityRows.length) {
-                let row = Math.max(parseInt(sortedActivityRows[sortedActivityRows.length - 1], 10), minimumActivityRow);
-                currentRow = row + ROW_HEIGHT + ROW_PADDING;
+                currentRow = parseInt(sortedActivityRows[sortedActivityRows.length - 1], 10) + ROW_HEIGHT + ROW_PADDING;
            }

-            return (currentRow || minimumActivityRow);
+            return (currentRow || defaultActivityRow);
        },
        calculatePlanLayout() {
            this.activitiesByRow = {};
@@ -245,9 +236,8 @@ export default {
            let groups = Object.keys(this.json);
            groups.forEach((key, index) => {
                let activities = this.json[key];
-                //set the new group's first row. It should be greater than the largest row of the last group
-                let sortedActivityRows = Object.keys(this.activitiesByRow).sort(this.sortFn);
-                const groupRowStart = sortedActivityRows.length ? parseInt(sortedActivityRows[sortedActivityRows.length - 1], 10) + 1 : 0;
+                //set the currentRow to the beginning of the next logical row
+                currentRow = currentRow + ROW_HEIGHT * index;
                let newGroup = true;
                activities.forEach((activity) => {
                    if (this.isActivityInBounds(activity)) {
@@ -266,9 +256,9 @@ export default {
                        const textWidth = textStart + this.getTextWidth(textLines[0]) + TEXT_LEFT_PADDING;

                        if (activityNameFitsRect) {
-                            currentRow = this.getRowForActivity(rectX, rectWidth, groupRowStart);
+                            currentRow = this.getRowForActivity(rectX, rectWidth);
                        } else {
-                            currentRow = this.getRowForActivity(rectX, textWidth, groupRowStart);
+                            currentRow = this.getRowForActivity(rectX, textWidth);
                        }

                        let textY = parseInt(currentRow, 10) + (activityNameFitsRect ? INNER_TEXT_PADDING : OUTER_TEXT_PADDING);
--- a/src/plugins/timeline/pluginSpec.js
+++ b/src/plugins/timeline/pluginSpec.js
@@ -98,10 +98,6 @@ describe('the plugin', function () {

        beforeEach((done) => {
            planDomainObject = {
-                identifier: {
-                    key: 'test-object',
-                    namespace: ''
-                },
                type: 'plan',
                id: "test-object",
                selectFile: {
--- a/src/plugins/utcTimeSystem/LocalClockSpec.js
+++ b/src/plugins/utcTimeSystem/LocalClockSpec.js
@@ -1,9 +1,9 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2019, United States Government
+ * Open MCT Web, Copyright (c) 2014-2015, 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
+ * Open MCT Web 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.
@@ -14,15 +14,31 @@
 * License for the specific language governing permissions and limitations
 * under the License.
 *
- * Open MCT includes source code licensed under additional open source
+ * Open MCT Web 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 DuplicateAction from "./DuplicateAction";

-export default function () {
-    return function (openmct) {
-        openmct.actions.register(new DuplicateAction(openmct));
-    };
-}
+define(["./LocalClock"], function (LocalClock) {
+    describe("The LocalClock class", function () {
+        let clock;
+        let mockTimeout;
+        const timeoutHandle = {};
+
+        beforeEach(function () {
+            mockTimeout = jasmine.createSpy("timeout");
+            mockTimeout.and.returnValue(timeoutHandle);
+
+            clock = new LocalClock(0);
+            clock.start();
+        });
+
+        it("calls listeners on tick with current time", function () {
+            const mockListener = jasmine.createSpy("listener");
+            clock.on('tick', mockListener);
+            clock.tick();
+            expect(mockListener).toHaveBeenCalledWith(jasmine.any(Number));
+        });
+    });
+});
--- a/src/plugins/utcTimeSystem/UTCTimeSystemSpec.js
+++ b/src/plugins/utcTimeSystem/UTCTimeSystemSpec.js
@@ -0,0 +1,48 @@
+/*****************************************************************************
+ * Open MCT Web, Copyright (c) 2014-2015, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT Web 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 Web 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(['./UTCTimeSystem'], function (UTCTimeSystem) {
+    describe("The UTCTimeSystem class", function () {
+        let timeSystem;
+        let mockTimeout;
+
+        beforeEach(function () {
+            mockTimeout = jasmine.createSpy("timeout");
+            timeSystem = new UTCTimeSystem(mockTimeout);
+        });
+
+        it("Uses the UTC time format", function () {
+            expect(timeSystem.timeFormat).toBe('utc');
+        });
+
+        it("is UTC based", function () {
+            expect(timeSystem.isUTCBased).toBe(true);
+        });
+
+        it("defines expected metadata", function () {
+            expect(timeSystem.key).toBeDefined();
+            expect(timeSystem.name).toBeDefined();
+            expect(timeSystem.cssClass).toBeDefined();
+            expect(timeSystem.durationFormat).toBeDefined();
+        });
+    });
+});
--- a/src/plugins/utcTimeSystem/pluginSpec.js
+++ b/src/plugins/utcTimeSystem/pluginSpec.js
@@ -1,103 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-
-import LocalClock from './LocalClock.js';
-import UTCTimeSystem from './UTCTimeSystem';
-import {
-    createOpenMct,
-    resetApplicationState
-} from 'utils/testing';
-
-describe("The UTC Time System", () => {
-    const UTC_SYSTEM_AND_FORMAT_KEY = 'utc';
-    let openmct;
-    let utcTimeSystem;
-    let mockTimeout;
-
-    beforeEach(() => {
-        openmct = createOpenMct();
-        openmct.install(openmct.plugins.UTCTimeSystem());
-    });
-
-    afterEach(() => {
-        return resetApplicationState(openmct);
-    });
-
-    describe("plugin", function () {
-
-        beforeEach(function () {
-            mockTimeout = jasmine.createSpy("timeout");
-            utcTimeSystem = new UTCTimeSystem(mockTimeout);
-        });
-
-        it("is installed", () => {
-            let timeSystems = openmct.time.getAllTimeSystems();
-            let utc = timeSystems.find(ts => ts.key === UTC_SYSTEM_AND_FORMAT_KEY);
-
-            expect(utc).not.toEqual(-1);
-        });
-
-        it("can be set to be the main time system", () => {
-            openmct.time.timeSystem(UTC_SYSTEM_AND_FORMAT_KEY, {
-                start: 0,
-                end: 4
-            });
-
-            expect(openmct.time.timeSystem().key).toBe(UTC_SYSTEM_AND_FORMAT_KEY);
-        });
-
-        it("uses the utc time format", () => {
-            expect(utcTimeSystem.timeFormat).toBe(UTC_SYSTEM_AND_FORMAT_KEY);
-        });
-
-        it("is UTC based", () => {
-            expect(utcTimeSystem.isUTCBased).toBe(true);
-        });
-
-        it("defines expected metadata", () => {
-            expect(utcTimeSystem.key).toBe(UTC_SYSTEM_AND_FORMAT_KEY);
-            expect(utcTimeSystem.name).toBeDefined();
-            expect(utcTimeSystem.cssClass).toBeDefined();
-            expect(utcTimeSystem.durationFormat).toBeDefined();
-        });
-    });
-
-    describe("LocalClock class", function () {
-        let clock;
-        const timeoutHandle = {};
-
-        beforeEach(function () {
-            mockTimeout = jasmine.createSpy("timeout");
-            mockTimeout.and.returnValue(timeoutHandle);
-
-            clock = new LocalClock(0);
-            clock.start();
-        });
-
-        it("calls listeners on tick with current time", function () {
-            const mockListener = jasmine.createSpy("listener");
-            clock.on('tick', mockListener);
-            clock.tick();
-            expect(mockListener).toHaveBeenCalledWith(jasmine.any(Number));
-        });
-    });
-});
--- a/src/plugins/viewDatumAction/ViewDatumAction.js
+++ b/src/plugins/viewDatumAction/ViewDatumAction.js
@@ -56,7 +56,7 @@ export default class ViewDatumAction {
        });
    }
    appliesTo(objectPath, view = {}) {
-        let viewContext = (view.getViewContext && view.getViewContext()) || {};
+        let viewContext = view.getViewContext && view.getViewContext() || {};
        let datum = viewContext.getDatum;
        let enabled = viewContext.viewDatumAction;

--- a/src/selection/Selection.js
+++ b/src/selection/Selection.js
@@ -70,8 +70,11 @@ define(
            if (multiSelect) {
                this.handleMultiSelect(selectable);
            } else {
-                this.handleSingleSelect(selectable);
+                this.setSelectionStyles(selectable);
+                this.selected = [selectable];
            }
+
+            this.emit('change', this.selected);
        };

        /**
@@ -84,20 +87,6 @@ define(
                this.addSelectionAttributes(selectable);
                this.selected.push(selectable);
            }
-
-            this.emit('change', this.selected);
-        };
-
-        /**
-         * @private
-         */
-        Selection.prototype.handleSingleSelect = function (selectable) {
-            if (!_.isEqual([selectable], this.selected)) {
-                this.setSelectionStyles(selectable);
-                this.selected = [selectable];
-
-                this.emit('change', this.selected);
-            }
        };

        /**
--- a/src/styles/_controls.scss
+++ b/src/styles/_controls.scss
@@ -126,7 +126,7 @@ button {

 .c-icon-button {
    [class*='label'] {
-        opacity: 0.8;
+        opacity: 0.6;
    }

    &--mixed {
@@ -468,6 +468,9 @@ select {

    > * {
        flex: 0 0 auto;
+        //+ * {
+        //    margin-top: $interiorMarginSm;
+        //}
    }
 }

@@ -482,7 +485,7 @@ select {
        transition: $transIn;
        white-space: nowrap;

-        @include hover {
+        &:hover {
            background: $colorMenuHovBg;
            color: $colorMenuHovFg;
            &:before {
@@ -497,12 +500,8 @@ select {
            min-width: 1em;
        }

-        &:not([class*='icon']):before {
-             content: ''; // Enable :before so that menu items without an icon still indent properly
-        }
-
-        .menus-no-icon & {
-            &:before { display: none; }
+        &:not([class]):before {
+             content: ''; // Add this element so that menu items without an icon still indent properly
        }
    }
 }
@@ -735,6 +734,7 @@ select {
 .c-toolbar {
    display: flex;
    align-items: center;
+    justify-content: space-between;

    > * {
        // First level items
--- a/src/styles/_legacy-plots.scss
+++ b/src/styles/_legacy-plots.scss
@@ -47,7 +47,6 @@ mct-plot {
 .c-plot,
 .gl-plot {
    overflow: hidden;
-    min-height: 100px;

        .s-status-taking-snapshot & {
        .c-control-bar {
@@ -60,8 +59,14 @@ mct-plot {
    }

    /*********************** MISSING ITEM INDICATORS */
-    .is-status__indicator {
-        font-size: 0.8em;
+    .is-missing__indicator {
+        display: none;
+    }
+    .is-missing {
+        @include isMissing();
+        .is-missing__indicator {
+            font-size: 0.8em;
+        }
    }
 }

@@ -80,8 +85,7 @@ mct-plot {
        display: flex;
        flex: 1 1 auto;
        flex-direction: column;
-        overflow-y: auto;
-        overflow-x: hidden;
+        overflow: hidden;
    }

    &--stacked {
--- a/src/styles/_mixins.scss
+++ b/src/styles/_mixins.scss
@@ -129,26 +129,31 @@
    }
 }

-@mixin isStatus($absPos: false, $glyph: '', $color: $colorBodyFg) {
-    // Supports CSS classing as follows:
-    // is-status--missing, is-status--suspect, etc.
+@mixin isMissing($absPos: false) {
    // Common styles to be applied to tree items, object labels, grid and list item views
+    //opacity: 0.7;
+    //pointer-events: none; // Don't think we can do this, as disables title hover on icon element

-    .is-status__indicator {
-        display: block ; // Set to display: none in status.scss
+    .is-missing__indicator {
+        display: none ;
        text-shadow: $colorBodyBg 0 0 2px;
+        color: $colorAlert;
        font-family: symbolsfont;

-        @if $absPos {
+        &:before {
+            content: $glyph-icon-alert-triangle;
+        }
+    }
+
+    @if $absPos {
+        .is-missing__indicator {
            position: absolute;
            z-index: 3;
        }
-
-        &:before {
-            color: $color;
-            content: $glyph;
-        }
    }
+
+    &.is-missing .is-missing__indicator,
+    .is-missing .is-missing__indicator { display: block !important; }
 }

@mixin bgDiagonalStripes($c: yellow, $a: 0.1, $d: 40px) {
@@ -552,8 +557,7 @@
        }
    }

-    &[class*='--menus-left'],
-    &[class*='menus-to-left'] {
+    &[class*='--menus-left'] {
        .c-menu {
            left: auto; right: 0;
        }
--- a/src/styles/_status.scss
+++ b/src/styles/_status.scss
@@ -198,17 +198,3 @@ tr {

 .u-alert { @include uIndicator($colorAlert, $colorAlertFg, $glyph-icon-alert-triangle); }
 .u-error { @include uIndicator($colorError, $colorErrorFg, $glyph-icon-alert-triangle); }
-
-.is-status {
-    &__indicator {
-        display: none; // Default state; is set to block when within an actual is-status class
-    }
-
-    &--missing {
-        @include isStatus($glyph: $glyph-icon-alert-triangle, $color: $colorAlert);
-    }
-
-    &--suspect {
-        @include isStatus($glyph: $glyph-icon-alert-rect, $color: $colorWarningLo);
-    }
-}
--- a/src/styles/notebook.scss
+++ b/src/styles/notebook.scss
@@ -25,7 +25,6 @@
    $headerFontSize: 1.3em;
    display: flex;
    flex-direction: column;
-    flex: 1 1 auto;
    overflow: hidden;
    height: 100%;

@@ -213,16 +212,17 @@
    }
 }

-.is-notebook-default,
-.is-status--notebook-default {
+.is-notebook-default {
    &:after {
        color: $colorFilter;
+        content: $glyph-icon-notebook-page;
+        display: block;
        font-family: symbolsfont;
        font-size: 0.9em;
+        margin-left: $interiorMargin;
    }

    &.c-list__item:after {
-        content: $glyph-icon-notebook-page;
        flex: 1 0 auto;
        text-align: right;
    }
--- a/src/styles/vue-styles.scss
+++ b/src/styles/vue-styles.scss
@@ -48,7 +48,3 @@
@import "../ui/toolbar/components/toolbar-checkbox.scss";
@import "./notebook.scss";
@import "../plugins/notebook/components/sidebar.scss";
-
-#splash-screen {
-     display: none;
-}
--- a/src/ui/components/ObjectFrame.vue
+++ b/src/ui/components/ObjectFrame.vue
@@ -23,11 +23,11 @@
 <div
    class="c-so-view"
    :class="[
-        statusClass,
        'c-so-view--' + domainObject.type,
        {
            'c-so-view--no-frame': !hasFrame,
-            'has-complex-content': complexContent
+            'has-complex-content': complexContent,
+            'is-missing': domainObject.status === 'missing'
        }
    ]"
 >
@@ -35,13 +35,16 @@
        class="c-so-view__header"
    >
        <div class="c-object-label"
-             :class="[ statusClass ]"
+             :class="{
+                 classList,
+                 'is-missing': domainObject.status === 'missing'
+             }"
        >
            <div class="c-object-label__type-icon"
                 :class="cssClass"
            >
-                <span class="is-status__indicator"
-                      :title="`This item is ${status}`"
+                <span class="is-missing__indicator"
+                      title="This item is missing"
                ></span>
            </div>
            <div class="c-object-label__name">
@@ -85,6 +88,9 @@
        </div>
    </div>

+    <div class="is-missing__indicator"
+         title="This item is missing"
+    ></div>
    <object-view
        ref="objectView"
        class="c-so-view__object-view"
@@ -93,7 +99,7 @@
        :object-path="objectPath"
        :layout-font-size="layoutFontSize"
        :layout-font="layoutFont"
-        @change-action-collection="setActionCollection"
+        @change-provider="setViewProvider"
    />
 </div>
 </template>
@@ -146,25 +152,28 @@ export default {

        let complexContent = !SIMPLE_CONTENT_TYPES.includes(this.domainObject.type);

+        let viewProvider = {};
+
+        let statusBarItems = {};
+
        return {
            cssClass,
            complexContent,
-            statusBarItems: [],
-            status: ''
+            viewProvider,
+            statusBarItems
        };
    },
    computed: {
-        statusClass() {
-            return (this.status) ? `is-status--${this.status}` : '';
+        classList() {
+            const classList = this.domainObject.classList;
+            if (!classList || !classList.length) {
+                return '';
+            }
+
+            return classList.join(' ');
        }
    },
-    mounted() {
-        this.status = this.openmct.status.get(this.domainObject.identifier);
-        this.removeStatusListener = this.openmct.status.observe(this.domainObject.identifier, this.setStatus);
-    },
    beforeDestroy() {
-        this.removeStatusListener();
-
        if (this.actionCollection) {
            this.unlistenToActionCollection();
        }
@@ -196,7 +205,6 @@ export default {
        },
        getPreviewHeader() {
            const domainObject = this.objectPath[0];
-            const actionCollection = this.actionCollection;
            const preview = new Vue({
                components: {
                    PreviewHeader
@@ -207,11 +215,10 @@ export default {
                },
                data() {
                    return {
-                        domainObject,
-                        actionCollection
+                        domainObject
                    };
                },
-                template: '<PreviewHeader :actionCollection="actionCollection" :domainObject="domainObject" :hideViewSwitcher="true" :showNotebookMenuSwitcher="true"></PreviewHeader>'
+                template: '<PreviewHeader :domainObject="domainObject" :hideViewSwitcher="true" :showNotebookMenuSwitcher="true"></PreviewHeader>'
            });

            return preview.$mount().$el;
@@ -219,17 +226,27 @@ export default {
        getSelectionContext() {
            return this.$refs.objectView.getSelectionContext();
        },
-        setActionCollection(actionCollection) {
+        setViewProvider(provider) {
+            this.viewProvider = provider;
+            this.initializeStatusBarItems();
+        },
+        initializeStatusBarItems() {
            if (this.actionCollection) {
                this.unlistenToActionCollection();
            }

-            this.actionCollection = actionCollection;
-            this.actionCollection.on('update', this.updateActionItems);
-            this.updateActionItems(this.actionCollection.applicableActions);
+            if (this.viewProvider) {
+                this.actionCollection = this.openmct.actions.get(this.objectPath, this.viewProvider);
+                this.actionCollection.on('update', this.updateActionItems);
+                this.updateActionItems(this.actionCollection.applicableActions);
+            } else {
+                this.statusBarItems = [];
+                this.menuActionItems = [];
+            }
        },
        unlistenToActionCollection() {
            this.actionCollection.off('update', this.updateActionItems);
+            this.actionCollection.destroy();
            delete this.actionCollection;
        },
        updateActionItems(actionItems) {
@@ -237,11 +254,16 @@ export default {
            this.menuActionItems = this.actionCollection.getVisibleActions();
        },
        showMenuItems(event) {
-            let sortedActions = this.openmct.actions._groupAndSortActions(this.menuActionItems);
+            let actions;
+
+            if (this.menuActionItems.length) {
+                actions = this.menuActionItems;
+            } else {
+                actions = this.openmct.actions.get(this.objectPath);
+            }
+
+            let sortedActions = this.openmct.actions._groupAndSortActions(actions);
            this.openmct.menus.showMenu(event.x, event.y, sortedActions);
-        },
-        setStatus(status) {
-            this.status = status;
        }
    }
 };
--- a/src/ui/components/ObjectLabel.vue
+++ b/src/ui/components/ObjectLabel.vue
@@ -1,7 +1,10 @@
 <template>
 <a
    class="c-tree__item__label c-object-label"
-    :class="[statusClass]"
+    :class="{
+        classList,
+        'is-missing': observedObject.status === 'missing'
+    }"
    draggable="true"
    :href="objectLink"
    @dragstart="dragStart"
@@ -11,8 +14,8 @@
        class="c-tree__item__type-icon c-object-label__type-icon"
        :class="typeClass"
    >
-        <span class="is-status__indicator"
-              :title="`This item is ${status}`"
+        <span class="is-missing__indicator"
+              title="This item is missing"
        ></span>
    </div>
    <div class="c-tree__item__name c-object-label__name">
@@ -42,126 +45,71 @@ export default {
        navigateToPath: {
            type: String,
            default: undefined
-        },
-        liteObject: {
-            type: Boolean,
-            default: false
-        },
-        beforeInteraction: {
-            type: Function,
-            required: false,
-            default: undefined
        }
    },
    data() {
        return {
-            observedObject: this.domainObject,
-            status: ''
+            observedObject: this.domainObject
        };
    },
    computed: {
+        classList() {
+            const classList = this.observedObject.classList;
+            if (!classList || !classList.length) {
+                return '';
+            }
+
+            return classList.join(' ');
+        },
        typeClass() {
-            let domainObjectType = this.liteObject ? this.domainObject.type : this.observedObject.type;
-            let type = this.openmct.types.get(domainObjectType);
+            let type = this.openmct.types.get(this.observedObject.type);
            if (!type) {
                return 'icon-object-unknown';
            }

            return type.definition.cssClass;
-        },
-        statusClass() {
-            return (this.status) ? `is-status--${this.status}` : '';
        }
    },
    mounted() {
-        // if it's a liteObject nothing to observe
-        if (this.observedObject && !this.liteObject) {
+        if (this.observedObject) {
            let removeListener = this.openmct.objects.observe(this.observedObject, '*', (newObject) => {
                this.observedObject = newObject;
            });
            this.$once('hook:destroyed', removeListener);
        }

-        // liteObjects do have identifiers, so statuses can be observed
-        this.removeStatusListener = this.openmct.status.observe(this.observedObject.identifier, this.setStatus);
-        this.status = this.openmct.status.get(this.observedObject.identifier);
        this.previewAction = new PreviewAction(this.openmct);
    },
-    destroyed() {
-        this.removeStatusListener();
-    },
    methods: {
-        async navigateOrPreview(event) {
-            // skip if editing or is a lite object with an interaction function
-            if (this.openmct.editor.isEditing() || !(this.liteObject && this.beforeInteraction)) {
-                return;
-            }
-
-            event.preventDefault();
-
+        navigateOrPreview(event) {
            if (this.openmct.editor.isEditing()) {
+                event.preventDefault();
                this.preview();
-            } else if (this.liteObject && this.beforeInteraction) {
-                let fullObjectInfo = await this.getFullObjectInfo();
-                // need to update when new route functions are merged (back button PR)
-                window.location.href = '#/browse/' + fullObjectInfo.navigationPath;
            }
        },
-        async preview() {
-            let objectPath = this.objectPath;
-
-            if (this.liteObject && this.beforeInteraction) {
-                let fullObjectInfo = await this.getFullObjectInfo();
-                objectPath = fullObjectInfo.objectPath;
-            }
-
-            if (this.previewAction.appliesTo(objectPath)) {
-                this.previewAction.invoke(objectPath);
+        preview() {
+            if (this.previewAction.appliesTo(this.objectPath)) {
+                this.previewAction.invoke(this.objectPath);
            }
        },
        dragStart(event) {
-            const LITE_DOMAIN_OBJECT_TYPE = "openmct/domain-object-lite";
-
            let navigatedObject = this.openmct.router.path[0];
-            let keyString = this.openmct.objects.makeKeyString(this.domainObject.identifier);
            let serializedPath = JSON.stringify(this.objectPath);
+            let keyString = this.openmct.objects.makeKeyString(this.domainObject.identifier);

-            if (this.liteObject) {
-                event.dataTransfer.setData(LITE_DOMAIN_OBJECT_TYPE, JSON.stringify(this.domainObject.identifier));
-
-            } else {
-
-                /*
-                * Cannot inspect data transfer objects on dragover/dragenter so impossible to determine composability at
-                * that point. If dragged object can be composed by navigated object, then indicate with presence of
-                * 'composable-domain-object' in data transfer
-                */
-                if (this.openmct.composition.checkPolicy(navigatedObject, this.observedObject)) {
-                    event.dataTransfer.setData("openmct/composable-domain-object", JSON.stringify(this.domainObject));
-                }
-
-                // serialize domain object anyway, because some views can drag-and-drop objects without composition
-                // (eg. notabook.)
-                event.dataTransfer.setData("openmct/domain-object-path", serializedPath);
-                event.dataTransfer.setData(`openmct/domain-object/${keyString}`, this.domainObject);
+            /*
+             * Cannot inspect data transfer objects on dragover/dragenter so impossible to determine composability at
+             * that point. If dragged object can be composed by navigated object, then indicate with presence of
+             * 'composable-domain-object' in data transfer
+             */
+            if (this.openmct.composition.checkPolicy(navigatedObject, this.observedObject)) {
+                event.dataTransfer.setData("openmct/composable-domain-object", JSON.stringify(this.domainObject));
            }
-        },
-        async getFullObjectInfo() {
-            let fullObjectInfo = await this.beforeInteraction();
-            let objectPath = fullObjectInfo.objectPath;
-            let navigationPath = objectPath
-                .reverse()
-                .map(object =>
-                    this.openmct.objects.makeKeyString(object.identifier)
-                ).join('/');

-            fullObjectInfo.objectPath = objectPath;
-            fullObjectInfo.navigationPath = navigationPath;
-
-            return fullObjectInfo;
-        },
-        setStatus(status) {
-            this.status = status;
+            // serialize domain object anyway, because some views can drag-and-drop objects without composition
+            // (eg. notabook.)
+            event.dataTransfer.setData("openmct/domain-object-path", serializedPath);
+            event.dataTransfer.setData(`openmct/domain-object/${keyString}`, this.domainObject);
        }
    }
 };
--- a/src/ui/components/ObjectView.vue
+++ b/src/ui/components/ObjectView.vue
@@ -74,11 +74,6 @@ export default {
            this.styleRuleManager.destroy();
            delete this.styleRuleManager;
        }
-
-        if (this.actionCollection) {
-            this.actionCollection.destroy();
-            delete this.actionCollection;
-        }
    },
    created() {
        this.debounceUpdateView = _.debounce(this.updateView, 10);
@@ -154,7 +149,6 @@ export default {

            let keys = Object.keys(styleObj);
            let elemToStyle = this.getStyleReceiver();
-
            keys.forEach(key => {
                if (elemToStyle) {
                    if ((typeof styleObj[key] === 'string') && (styleObj[key].indexOf('__no_value') > -1)) {
@@ -213,7 +207,6 @@ export default {
                }
            }

-            this.getActionCollection();
            this.currentView.show(this.viewContainer, this.openmct.editor.isEditing());

            if (immediatelySelect) {
@@ -221,16 +214,9 @@ export default {
                    this.$el, this.getSelectionContext(), true);
            }

+            this.$emit('change-provider', this.currentView);
            this.openmct.objectViews.on('clearData', this.clearData);
        },
-        getActionCollection() {
-            if (this.actionCollection) {
-                this.actionCollection.destroy();
-            }
-
-            this.actionCollection = this.openmct.actions._get(this.currentObjectPath || this.objectPath, this.currentView);
-            this.$emit('change-action-collection', this.actionCollection);
-        },
        show(object, viewKey, immediatelySelect, currentObjectPath) {
            this.updateStyle();

--- a/src/ui/components/object-frame.scss
+++ b/src/ui/components/object-frame.scss
@@ -9,7 +9,6 @@
        justify-content: space-between;
        align-items: center;
        margin-bottom: $interiorMarginSm;
-        overflow: hidden;
        padding: 3px;

        .c-object-label {
@@ -36,7 +35,6 @@
    /*************************** FRAME CONTROLS */
    &__frame-controls {
        display: flex;
-        flex: 0 0 auto;

        &__btns,
        &__more {
@@ -112,8 +110,13 @@
            }
        }

-        &[class*='is-status'] {
-            border: $borderMissing;
+        &.is-missing {
+            @include isMissing($absPos: true);
+
+            .is-missing__indicator {
+                top: $interiorMargin;
+                left: $interiorMargin;
+            }
        }
    }

@@ -142,25 +145,13 @@
        > .c-so-view__view-large { display: block; }
    }

-    &.is-status--missing {
+    &.is-missing {
        border: $borderMissing;
    }
-
-    &__object-view {
-        display: flex;
-        flex: 1 1 auto;
-        overflow: auto;
-
-        .u-fills-container {
-            // Expand component types that fill a container
-            @include abs();
-        }
-    }
 }

 .l-angular-ov-wrapper {
    // This element is the recipient for object styling; cannot be display: contents
-    flex: 1 1 auto;
+    height: 100%;
    overflow: hidden;
-    display: block;
 }
--- a/src/ui/components/object-label.scss
+++ b/src/ui/components/object-label.scss
@@ -19,31 +19,20 @@
        display: block;
        flex: 0 0 auto;
        font-size: 1.1em;
-        opacity: $objectLabelTypeIconOpacity;
    }

-    .is-status__indicator {
-        position: absolute;
-        right: -3px;
-        top: -3px;
-        transform: scale(0.5);
-    }
+    &.is-missing {
+        @include isMissing($absPos: true);

-    &.is-status--missing,
-    &.is-status--suspect {
-        [class*='__type-icon'] {
-            &:before,
-            &:after {
-                opacity: $opacityMissing;
-            }
+        [class*='__type-icon']:before,
+        [class*='__type-icon']:after{
+            opacity: $opacityMissing;
        }
-    }

-    &.is-status--notebook-default {
-        &:after {
-            content: $glyph-icon-notebook-page;
-            display: block;
-            margin-left: $interiorMargin;
+        .is-missing__indicator {
+            right: -3px;
+            top: -3px;
+            transform: scale(0.7);
        }
    }
 }
--- a/src/ui/inspector/ObjectName.vue
+++ b/src/ui/inspector/ObjectName.vue
@@ -2,13 +2,13 @@
 <div class="c-inspector__header">
    <div v-if="!multiSelect"
         class="c-inspector__selected c-object-label"
-         :class="[statusClass]"
+         :class="{'is-missing': isMissing }"
    >
        <div class="c-object-label__type-icon"
             :class="typeCssClass"
        >
-            <span class="is-status__indicator"
-                  :title="`This item is ${status}`"
+            <span class="is-missing__indicator"
+                  title="This item is missing"
            ></span>
        </div>
        <span v-if="!singleSelectNonObject"
@@ -37,10 +37,8 @@ export default {
    data() {
        return {
            domainObject: {},
-            keyString: undefined,
            multiSelect: false,
-            itemsSelected: 0,
-            status: undefined
+            itemsSelected: 0
        };
    },
    computed: {
@@ -60,8 +58,9 @@ export default {
        singleSelectNonObject() {
            return !this.item.identifier && !this.multiSelect;
        },
-        statusClass() {
-            return this.status ? `is-status--${this.status}` : '';
+        isMissing() {
+            // safe check this.domainObject since for layout objects this.domainOjbect is undefined
+            return this.domainObject && this.domainObject.status === 'missing';
        }
    },
    mounted() {
@@ -70,48 +69,25 @@ export default {
    },
    beforeDestroy() {
        this.openmct.selection.off('change', this.updateSelection);
-
-        if (this.statusUnsubscribe) {
-            this.statusUnsubscribe();
-        }
    },
    methods: {
        updateSelection(selection) {
-            if (this.statusUnsubscribe) {
-                this.statusUnsubscribe();
-                this.statusUnsubscribe = undefined;
-            }
-
            if (selection.length === 0 || selection[0].length === 0) {
-                this.resetDomainObject();
+                this.domainObject = {};

                return;
            }

            if (selection.length > 1) {
                this.multiSelect = true;
+                this.domainObject = {};
                this.itemsSelected = selection.length;
-                this.resetDomainObject();

                return;
            } else {
                this.multiSelect = false;
                this.domainObject = selection[0][0].context.item;
-
-                if (this.domainObject) {
-                    this.keyString = this.openmct.objects.makeKeyString(this.domainObject.identifier);
-                    this.status = this.openmct.status.get(this.keyString);
-                    this.statusUnsubscribe = this.openmct.status.observe(this.keyString, this.updateStatus);
-                }
            }
-        },
-        resetDomainObject() {
-            this.domainObject = {};
-            this.status = undefined;
-            this.keyString = undefined;
-        },
-        updateStatus(status) {
-            this.status = status;
        }
    }
 };
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Deep Tailor	02be8a9875	merge with master	2020-11-03 13:48:28 -08:00
Deep Tailor	3bd57c8fff	add tests for actionsAPI	2020-11-03 13:43:45 -08:00
Deep Tailor	94091b25ec	remove focused describe	2020-11-02 11:09:59 -08:00
Deep Tailor	c191ffb37d	add tests for MenuAPI	2020-11-02 11:06:59 -08:00
Deep Tailor	eb709a60cb	Merge branch 'master' of https://github.com/nasa/openmct into three-dot-menu-proto	2020-10-29 15:24:51 -07:00
Deep Tailor	bf3fd66942	fix broken export marked rows	2020-10-20 16:54:53 -07:00
Deep Tailor	8414ded1ec	Merge branch 'master' into three-dot-menu-proto	2020-10-19 18:01:44 -07:00
Deep Tailor	646c871c76	Merge branch 'master' of https://github.com/nasa/openmct into three-dot-menu-proto	2020-10-19 10:29:38 -07:00
Deep Tailor	ba401b3341	fix lint errors	2020-10-18 15:55:39 -07:00
Deep Tailor	5ef02ec4a2	git enable legacy toolbar for legacy tables	2020-10-15 11:55:21 -07:00
Deep Tailor	d788031019	Merge branch 'master' of https://github.com/nasa/openmct into three-dot-menu-proto	2020-10-15 09:49:32 -07:00
Nikhil	d870874649	Alphanumeric notebook entry (#3387 ) * [Notebook] Copy label and value from alphanumeric in Layout directly to a Notebook entry #3299 * changes to use updated action API. * added 'copyToNotebook' + some refactor. * Added current default notebook name to 'Copy to Notebook' string. * string delimiter updated. * cleanup * updated per review comments * updated as per review comments. * fixed rebase issue. * corrected case in import. * fixed lint errors. * fixed test error, Unhandled promise rejection: TypeError: 'clipboard-write' * removed navigator.permissions.query check	2020-10-07 14:01:36 -07:00
Deep Tailor	711a7a2eb5	fix console error on changing types and canceling edit	2020-10-07 12:30:07 -07:00
Deep Tailor	c105a08cfe	add tests for viewDatum action plugin	2020-10-06 15:35:08 -07:00
Deep Tailor	b87375a809	remove vue style	2020-10-06 12:37:28 -07:00
Deep Tailor	9fed056d22	add a viewDatum Action	2020-10-06 12:37:00 -07:00
Deep Tailor	251bf21933	Merge branch 'master' into three-dot-menu-proto	2020-10-05 11:25:55 -07:00
Deep Tailor	a180bf7c02	fix lint error	2020-10-05 11:16:34 -07:00
Deep Tailor	ed8a54f0f9	fix broken spec files	2020-10-05 11:12:07 -07:00
Deep Tailor	ff3c2da0f9	fix broken tests and add update on isEditing for actionCollections	2020-10-05 10:31:01 -07:00
Deep Tailor	28d5821120	fix lint issues	2020-10-02 15:08:07 -07:00
Deep Tailor	f5ee457274	Merge branch 'master' into three-dot-menu-proto	2020-10-02 15:02:20 -07:00
Deep Tailor	9d2770e4d2	update according to andrews comments	2020-10-02 15:01:04 -07:00
Deep Tailor	8b25009816	reverse check for viewProvider.getViewContext	2020-10-02 11:48:47 -07:00
Deep Tailor	074fe4481a	linting fixes	2020-10-02 11:42:41 -07:00
Deep Tailor	fbd928b842	Merge branch 'master' of https://github.com/nasa/openmct into three-dot-menu-proto	2020-10-02 11:25:43 -07:00
Deep Tailor	110947db09	update according to review comments	2020-10-02 11:22:18 -07:00
Deep Tailor	ef91e92fbc	wip	2020-09-30 13:13:50 -07:00
Deep Tailor	d201cac4ac	update changes	2020-09-30 13:07:18 -07:00
Deep Tailor	dcb3ccfec7	use weak map to cache actionCollections	2020-09-30 12:44:28 -07:00
Deep Tailor	78522cd4f1	remove unecessary computed properties	2020-09-16 10:07:20 -07:00
Deep Tailor	ca232d45cc	notebook and menu switchers to use menu api	2020-09-16 09:57:29 -07:00
Deep Tailor	df495c841a	merge master	2020-09-16 09:07:26 -07:00
Deep Tailor	92a37ef36b	Merge branch 'master' into three-dot-menu-proto	2020-09-14 09:52:10 -07:00
Deep Tailor	fd731ca430	fix ladrow and tablerow use of contextMenus	2020-09-09 14:18:20 -07:00
Deep Tailor	263b1cd3d5	fix telemetry view view historical	2020-09-09 13:58:28 -07:00
Deep Tailor	978fc8b5a3	performance enhancements	2020-09-09 11:37:49 -07:00
Deep Tailor	698ccc5a35	fix bug with object update	2020-09-09 10:15:19 -07:00
Deep Tailor	e5aa5b5a5f	fix onDestroy error	2020-09-08 16:06:45 -07:00
Deep Tailor	b942988ef8	Merge branch 'master' of https://github.com/nasa/openmct into three-dot-menu-proto	2020-09-08 16:00:10 -07:00
Deep Tailor	1eec20f2ea	3 dot menu refactor (#3360 ) * refactoring actions api * wip * wip * almost done * fix lint issues	2020-09-08 15:59:42 -07:00
charlesh88	767a2048eb	Three dot menu implementation WIP - Hide frame control labels when object is within a Flexible Layout;	2020-09-03 13:04:48 -07:00
charlesh88	e65cf1661c	Three dot menu implementation WIP - Recast "Preview" action as "View";	2020-09-01 10:08:36 -07:00
charlesh88	0eae48646c	Three dot menu implementation WIP - Merge latest master, fix conflicts;	2020-08-31 14:09:01 -07:00
charlesh88	0ba8a275d2	Three dot menu implementation WIP - Fixed button title;	2020-08-27 08:56:32 -07:00
charlesh88	d8d32cc3ac	Three dot menu implementation WIP - Changed Snapshot-related buttons and menus to use `icon-camera`; - Normalized padding for c-icon-buttons; - Added a CSS class `c-so-view--<domainObject.type>` to allow sub-layouts with hidden frames to completely hide their headers and buttons - this is needed to avoid overlap collisions with further sub-objects; - Changed button styling in main view to be more in line with 'iconic' approach used elsewhere, enabled button labels where applicable; - Better, more consistent hover approach for `c-button` and `c-icon-button` controls; - Changed Snow theme constant hover `filter` value for better color matching; - Fixed `c-object-label` type-icon opacity; - Changed Snow theme constant for object name to fix inline editing of object name being too dark;	2020-08-25 18:47:55 -07:00
charlesh88	a800848fe1	Three dot menu implementation WIP - Make button labels hide/show based on frame size in Layout;	2020-08-25 14:30:40 -07:00
charlesh88	6881d98ba6	Three dot menu implementation WIP - Initial styling and hover behavior for Layout frame controls; - Defined default color for c-icon-buttons; - Changed buttons from `c-button` to `c-icon-button`;	2020-08-21 18:42:32 -07:00
charlesh88	48d077cd2e	Three dot menu implementation WIP - Merge in `add-glyphs-082020`;	2020-08-20 14:08:15 -07:00
charlesh88	030dd93c91	Add new glyphs - Grid on, grid off and camera;	2020-08-20 11:10:22 -07:00
charlesh88	03bf6fc0a3	Three dot menu implementation WIP - Add icomoon config JSON file;	2020-08-20 10:09:03 -07:00
charlesh88	ef0a2ed5d2	Three dot menu implementation WIP - Add new `icon-3-dots` glyph;	2020-08-20 10:08:52 -07:00
charlesh88	a40aa84752	Three dot menu implementation WIP - Add icomoon config JSON file;	2020-08-19 14:40:22 -07:00
charlesh88	d3b69dda82	Three dot menu implementation WIP - Add new `icon-3-dots` glyph;	2020-08-19 14:38:47 -07:00
charlesh88	d3126ebf5c	Three dot menu implementation WIP - Replace inline styling; - Style for c-menu `__section-separator` and `__section-hint` refined;	2020-08-19 12:59:20 -07:00
Deep Tailor	4479cbc7a2	abstract logic into actionAPI	2020-08-18 16:26:20 -07:00
Deep Tailor	f8ff44dac0	wip	2020-08-18 15:52:59 -07:00
Deep Tailor	8f4280d15b	fix table row marking	2020-08-18 15:43:00 -07:00
Deep Tailor	6daa27ff31	merge with master	2020-08-18 15:24:15 -07:00
Deep Tailor	43f6c3f85d	wip	2020-08-18 15:12:39 -07:00
Deep Tailor	1a7c76cf3e	updated to new actions API	2020-08-18 13:56:26 -07:00
Deep Tailor	cee9cd7bd1	working groups	2020-08-14 10:15:13 -07:00
Deep Tailor	c42df20281	combine domainObject actions and view actions	2020-08-13 18:42:58 -07:00
Deep Tailor	b4149bd2b3	working in objectFrame	2020-08-13 17:39:35 -07:00
Deep Tailor	f436ac9ba0	working proto	2020-08-13 16:26:29 -07:00
Deep Tailor	8493b481dd	make reviewer requested changes	2020-08-13 14:46:18 -07:00
Deep Tailor	28723b59b7	Merge branch 'master' into context-menu-option	2020-06-10 16:36:33 -07:00
Deep Tailor	9fa7de0b77	remove unused files	2020-06-10 16:30:24 -07:00
Deep Tailor	54bfc84ada	replaced contextMenu with overlay menu	2020-06-10 16:06:42 -07:00