fix status class

* wip

* simplifying class applications

* add status to tabs view

* add tests for status API

* fix lint errors

* fix style application in telemetry vue

* CSS and markup refactoring to support addition of 'suspect' telemetry (#3499)

* CSS and markup refactoring to support addition of 'suspect' telemetry

- Significant refactoring of CSS classing: `is-missing` is now
`is-status--missing` and `is-missing__indicator` is now simply
`is-status__indicator`, allowing the wrapping `is-missing--*` class to
control what is displayed;
- New SCSS mixin @isStatus, and changes to mixin @isMissing to support
new `is-status--suspect` class;
- Changed titling for missing objects from 'This item is missing' to
'This item is missing or suspect'. **IMPORTANT NOTE** This is temporary
and should be replaced with a more robust approach to titling that
allows title strings to be defined in configuration and dynamically
applied;
- Refactored computed property `statusClass` across multiple components
to return an empty string when status is undefined - this was
previously erroneously returning `is-undefined` in that circumstance;
- Removed commented code;

* CSS and markup refactoring to support addition of 'suspect' telemetry

- Refinements to broaden capability of `is-status*` mixin;

* fix lint issues

Co-authored-by: Charles Hacskaylo <charlesh88@gmail.com>

CONTRIBUTING.md

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

index.html

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

karma.conf.js

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

package.json

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

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",

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;
+    }
+);

platform/entanglement/src/actions/MoveAction.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;
+    }
+);
+

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;
+});

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;
+    }
+);
+

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);
+                });
+            });
+        });
+    }
+);

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);
+                });
+            });
+        });
+    }
+);

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);
+            });
+        });
+    });
+});

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;
+    }
+);

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);
+                    });
+                });
+
+            });
+        });
+    }
+);

platform/search/src/services/BareBonesSearchWorker.js

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

platform/search/src/services/GenericSearchProvider.js

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

platform/search/src/services/GenericSearchWorker.js

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

src/MCT.js

@@ -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
 ) {
     /**
@@ -267,8 +263,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 +276,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);

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);
     }

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);
-        });
-    });
-});

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);

src/api/actions/ActionsAPISpec.js

@@ -22,41 +22,22 @@
 
 import ActionsAPI from './ActionsAPI';
 import { createOpenMct, resetApplicationState } from '../../utils/testing';
-import ActionCollection from './ActionCollection';
 
 describe('The Actions API', () => {
     let openmct;
     let actionsAPI;
     let mockAction;
     let mockObjectPath;
-    let mockObjectPathAction;
     let mockViewContext1;
 
     beforeEach(() => {
         openmct = createOpenMct();
         actionsAPI = new ActionsAPI(openmct);
-        mockObjectPathAction = {
-            name: 'Test Action Object Path',
-            key: 'test-action-object-path',
-            cssClass: 'test-action-object-path',
-            description: 'This is a test action for object path',
-            group: 'action',
-            priority: 9,
-            appliesTo: (objectPath) => {
-                if (objectPath.length) {
-                    return objectPath[0].type === 'fake-folder';
-                }
-
-                return false;
-            },
-            invoke: () => {
-            }
-        };
         mockAction = {
-            name: 'Test Action View',
-            key: 'test-action-view',
-            cssClass: 'test-action-view',
-            description: 'This is a test action for view',
+            name: 'Test Action',
+            key: 'test-action',
+            cssClass: 'test-action',
+            description: 'This is a test action',
             group: 'action',
             priority: 9,
             appliesTo: (objectPath, view = {}) => {
@@ -64,6 +45,8 @@ describe('The Actions API', () => {
                     let viewContext = view.getViewContext();
 
                     return viewContext.onlyAppliesToTestCase;
+                } else if (objectPath.length) {
+                    return objectPath[0].type === 'fake-folder';
                 }
 
                 return false;
@@ -92,7 +75,8 @@ describe('The Actions API', () => {
         mockViewContext1 = {
             getViewContext: () => {
                 return {
-                    onlyAppliesToTestCase: true
+                    onlyAppliesToTestCase: true,
+                    skipCache: true
                 };
             }
         };
@@ -106,8 +90,7 @@ describe('The Actions API', () => {
         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 +100,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);

src/api/menu/MenuAPI.js

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

src/api/menu/MenuAPISpec.js

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

src/api/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);
-        });
-    }
-
-}
-

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.
      *

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();
-                });
-            });
         });
     });
 });

src/api/telemetry/TelemetryAPI.js

@@ -21,14 +21,12 @@
  *****************************************************************************/
 
 define([
-    '../../plugins/displayLayout/CustomStringFormatter',
     './TelemetryMetadataManager',
     './TelemetryValueFormatter',
     './DefaultMetadataProvider',
     'objectUtils',
     'lodash'
 ], function (
-    CustomStringFormatter,
     TelemetryMetadataManager,
     TelemetryValueFormatter,
     DefaultMetadataProvider,
@@ -144,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
@@ -413,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.
      *
@@ -431,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.

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);

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);
+                });
             });
         });
     });

src/plugins/condition/Condition.js

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

src/plugins/condition/ConditionManager.js

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

src/plugins/condition/StyleRuleManager.js

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

src/plugins/condition/pluginSpec.js

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

src/plugins/displayLayout/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;
-    }
-}

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);
-    });
-});

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;
     }
 }

src/plugins/displayLayout/components/TelemetryView.vue

@@ -30,7 +30,7 @@
 >
     <div
         v-if="domainObject"
-        class="c-telemetry-view u-style-receiver"
+        class="c-telemetry-view"
         :class="[statusClass]"
         :style="styleObject"
         :data-font-size="item.fontSize"
@@ -38,7 +38,7 @@
         @contextmenu.prevent="showContextMenu"
     >
         <div class="is-status__indicator"
-             :title="`This item is ${status}`"
+             :title="`This item is ${this.status}`"
         ></div>
         <div
             v-if="showLabel"
@@ -71,6 +71,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';
 
@@ -171,11 +172,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 +180,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) {
@@ -230,12 +231,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 +282,10 @@ export default {
         },
         getView() {
             return {
-                getViewContext: () => {
+                getViewContext() {
                     return {
                         viewHistoricalData: true,
-                        formattedValueForCopy: this.formattedValueForCopy
+                        skipCache: true
                     };
                 }
             };
@@ -290,10 +296,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,35 +313,36 @@ 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) {

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;
@@ -27,12 +28,19 @@
     }
 
     .is-status__indicator {
-        position: absolute;
         top: 0;
         left: 0;
     }
 
-    &[class*='is-status'] {
+    &.is-status--missing {
+        @include isMissing($absPos: true);
+
+        border: $borderMissing;
+    }
+
+    &.is-status--suspect {
+        @include isSuspect($absPos: true);
+
         border: $borderMissing;
     }
 }

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);
-    }
-}

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');
-    }
-}

src/plugins/duplicate/plugin.js

@@ -1,28 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2019, 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 DuplicateAction from "./DuplicateAction";
-
-export default function () {
-    return function (openmct) {
-        openmct.actions.register(new DuplicateAction(openmct));
-    };
-}

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);
-        });
-    });
-
-});

src/plugins/folderView/components/GridItem.vue

@@ -27,7 +27,7 @@
     </div>
     <div class="c-grid-item__controls">
         <div class="is-status__indicator"
-             :title="`This item is ${status}`"
+             title="This item is missing or suspect"
         ></div>
         <div
             class="icon-people"

src/plugins/folderView/components/ListItem.vue

@@ -1,9 +1,7 @@
 <template>
 <tr
     class="c-list-item"
-    :class="{
-        'is-alias': item.isAlias === true
-    }"
+    :class="{ 'is-alias': item.isAlias === true }"
     @click="navigate"
 >
     <td class="c-list-item__name">
@@ -18,7 +16,7 @@
                 :class="item.type.cssClass"
             >
                 <span class="is-status__indicator"
-                      :title="`This item is ${status}`"
+                      title="This item is missing or suspect"
                 ></span>
             </div>
             <div class="c-object-label__name c-list-item__name__name">{{ item.model.name }}</div>

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;
+            }
+        }
+    }
+}

src/plugins/folderView/components/grid-view.scss

@@ -43,20 +43,18 @@
         }
     }
 
-    &.is-status--notebook-default {
-        .is-status__indicator {
-            display: block;
+    &.is-status--missing {
+        @include isMissing();
 
-            &:before {
-                color: $colorFilter;
-                content: $glyph-icon-notebook-page;
-                font-family: symbolsfont;
-            }
+        [class*='__type-icon'],
+        [class*='__details'] {
+            opacity: $opacityMissing;
         }
     }
 
-    &[class*='is-status--missing'],
-    &[class*='is-status--suspect']{
+    &.is-status--suspect {
+        @include isSuspect();
+
         [class*='__type-icon'],
         [class*='__details'] {
             opacity: $opacityMissing;

src/plugins/imagery/components/ImageryViewLayout.vue

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

src/plugins/imagery/pluginSpec.js

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

src/plugins/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);
-    };
-}

src/plugins/localTimeSystem/pluginSpec.js

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

src/plugins/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);
-    }
-}

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));
-    };
-}

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);
-        });
-    });
-
-});

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;
     }
 }

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 { addNotebookEntry, createNewEmbed, getNotebookEntries } from '../utils/notebook-entries';
 import objectUtils from 'objectUtils';
 
 import { throttle } from 'lodash';
@@ -220,17 +220,19 @@ export default {
                 return s;
             });
 
-            this.sectionsChanged({ sections });
+            this.updateSection({ sections });
             this.throttledSearchItem('');
         },
         createNotebookStorageObject() {
             const notebookMeta = {
+                name: this.internalDomainObject.name,
                 identifier: this.internalDomainObject.identifier
             };
             const page = this.getSelectedPage();
             const section = this.getSelectedSection();
 
             return {
+                domainObject: this.internalDomainObject,
                 notebookMeta,
                 section,
                 page
@@ -307,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);
@@ -377,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) {
@@ -393,7 +398,7 @@ export default {
                 return s;
             });
 
-            this.sectionsChanged({ sections });
+            this.updateSection({ sections });
         },
         newEntry(embed = null) {
             this.search = '';
@@ -406,24 +411,6 @@ 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;
@@ -440,20 +427,18 @@ export default {
         async updateDefaultNotebook(notebookStorage) {
             const defaultNotebookObject = await this.getDefaultNotebookObject();
             if (!defaultNotebookObject) {
-                setDefaultNotebook(this.openmct, notebookStorage, this.internalDomainObject);
+                setDefaultNotebook(this.openmct, notebookStorage);
             } else if (objectUtils.makeKeyString(defaultNotebookObject.identifier) !== objectUtils.makeKeyString(notebookStorage.notebookMeta.identifier)) {
                 this.removeDefaultClass(defaultNotebookObject);
-                setDefaultNotebook(this.openmct, notebookStorage, this.internalDomainObject);
+                setDefaultNotebook(this.openmct, notebookStorage);
             }
 
-            if (this.defaultSectionId && this.defaultSectionId.length === 0 || this.defaultSectionId !== notebookStorage.section.id) {
+            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) {
@@ -517,11 +502,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) {
@@ -545,8 +548,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);

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);

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

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);

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);

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
             });

src/plugins/notebook/pluginSpec.js

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

src/plugins/notebook/snapshot.js

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

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

@@ -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);
+    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,11 +196,7 @@ export function deleteNotebookEntries(openmct, domainObject, selectedSection, se
 
     delete entries[selectedSection.id][selectedPage.id];
 
-    mutateObject(openmct, domainObject, 'configuration.entries', entries);
-}
-
-export function mutateObject(openmct, object, key, value) {
-    openmct.objects.mutate(object, key, value);
+    openmct.objects.mutate(domainObject, 'configuration.entries', entries);
 }
 
 function addDefaultClass(domainObject, openmct) {

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

@@ -20,9 +20,16 @@
  * 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: {
+        name: 'notebook',
+        identifier: {
+            namespace: '',
+            key: 'test-notebook'
+        }
+    },
     notebookMeta: {
         name: 'notebook',
         identifier: {
@@ -114,6 +121,7 @@ describe('Notebook Entries:', () => {
     beforeEach(done => {
         openmct = createOpenMct();
         window.localStorage.setItem('notebook-storage', null);
+        spyOnBuiltins(['mutate'], openmct.objects);
 
         done();
     });
@@ -129,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', () => {
@@ -158,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);
     });
 });

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

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

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

@@ -23,15 +23,14 @@
 import * as NotebookStorage from './notebook-storage';
 import { createOpenMct, resetApplicationState } from 'utils/testing';
 
-const domainObject = {
-    name: 'notebook',
-    identifier: {
-        namespace: '',
-        key: 'test-notebook'
-    }
-};
-
 const notebookStorage = {
+    domainObject: {
+        name: 'notebook',
+        identifier: {
+            namespace: '',
+            key: 'test-notebook'
+        }
+    },
     notebookMeta: {
         name: 'notebook',
         identifier: {
@@ -83,7 +82,7 @@ describe('Notebook Storage:', () => {
     });
 
     it('has correct notebookstorage on setDefaultNotebook', () => {
-        NotebookStorage.setDefaultNotebook(openmct, notebookStorage, domainObject);
+        NotebookStorage.setDefaultNotebook(openmct, notebookStorage);
         const defaultNotebook = NotebookStorage.getDefaultNotebook();
 
         expect(JSON.stringify(defaultNotebook)).toBe(JSON.stringify(notebookStorage));
@@ -99,7 +98,7 @@ describe('Notebook Storage:', () => {
             sectionTitle: 'Section'
         };
 
-        NotebookStorage.setDefaultNotebook(openmct, notebookStorage, domainObject);
+        NotebookStorage.setDefaultNotebook(openmct, notebookStorage);
         NotebookStorage.setDefaultNotebookSection(section);
 
         const defaultNotebook = NotebookStorage.getDefaultNotebook();
@@ -116,7 +115,7 @@ describe('Notebook Storage:', () => {
             pageTitle: 'Page'
         };
 
-        NotebookStorage.setDefaultNotebook(openmct, notebookStorage, domainObject);
+        NotebookStorage.setDefaultNotebook(openmct, notebookStorage);
         NotebookStorage.setDefaultNotebookPage(page);
 
         const defaultNotebook = NotebookStorage.getDefaultNotebook();

src/plugins/performanceIndicator/README.md

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

src/plugins/performanceIndicator/plugin.js

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

src/plugins/performanceIndicator/pluginSpec.js

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

src/plugins/persistence/couch/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]);
             }
 

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();

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

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

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

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

src/plugins/plugins.js

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

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="[tab.status ? `is-${tab.status}` : '']"
             >
                 <div class="c-object-label__type-icon"
                      :class="tab.type.definition.cssClass"
                 >
                     <span class="is-status__indicator"
-                          :title="`This item is ${tab.status}`"
+                          title="This item is missing or suspect"
                     ></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,12 @@ 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 +213,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 +254,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 +272,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);
-            }
         }
     }
 };

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>'

src/plugins/telemetryTable/TelemetryTableRow.js

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

src/plugins/telemetryTable/ViewActions.js

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

src/plugins/telemetryTable/components/table-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) {

src/plugins/telemetryTable/components/table.vue

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

src/plugins/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);

src/plugins/timeline/pluginSpec.js

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

src/plugins/utcTimeSystem/LocalClockSpec.js

@@ -1,9 +1,9 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2021, 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,16 +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 TimerViewProvider from './TimerViewProvider';
+define(["./LocalClock"], function (LocalClock) {
+    describe("The LocalClock class", function () {
+        let clock;
+        let mockTimeout;
+        const timeoutHandle = {};
 
-export default function TimerPlugin() {
-    return function install(openmct) {
-        openmct.objectViews.addProvider(new TimerViewProvider(openmct));
-    };
-}
+        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));
+        });
+    });
+});

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();
+        });
+    });
+});

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));
-        });
-    });
-});

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;
 

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);
-            }
         };
 
         /**

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

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 {
@@ -61,7 +60,13 @@ mct-plot {
 
     /*********************** MISSING ITEM INDICATORS */
     .is-status__indicator {
-        font-size: 0.8em;
+        display: none;
+    }
+    .is-status--missing {
+        @include isMissing();
+        .is-status__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 {

src/styles/_mixins.scss

@@ -129,25 +129,44 @@
     }
 }
 
-@mixin isStatus($absPos: false, $glyph: '', $color: $colorBodyFg) {
+@mixin isStatus($absPos: false) {
     // Supports CSS classing as follows:
     // is-status--missing, is-status--suspect, etc.
     // Common styles to be applied to tree items, object labels, grid and list item views
 
     .is-status__indicator {
-        display: block ; // Set to display: none in status.scss
+        display: none ;
         text-shadow: $colorBodyBg 0 0 2px;
         font-family: symbolsfont;
 
+        &[class^='is-status'] .is-status__indicator,
+        [class^='is-status'] .is-status__indicator {
+            display: block !important;
+        }
+
         @if $absPos {
+            display: block;
             position: absolute;
             z-index: 3;
         }
+    }
+}
 
-        &:before {
-            color: $color;
-            content: $glyph;
-        }
+@mixin isMissing($absPos: false) {
+    @include isStatus($absPos);
+
+    .is-status__indicator:before {
+        color: $colorAlert;
+        content: $glyph-icon-alert-triangle;
+    }
+}
+
+@mixin isSuspect($absPos: false) {
+    @include isStatus($absPos);
+
+    .is-status__indicator:before {
+        color: $colorWarningLo;
+        content: $glyph-icon-alert-rect;
     }
 }
 
@@ -552,8 +571,7 @@
         }
     }
 
-    &[class*='--menus-left'],
-    &[class*='menus-to-left'] {
+    &[class*='--menus-left'] {
         .c-menu {
             left: auto; right: 0;
         }

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);
-    }
-}

src/styles/notebook.scss

@@ -213,16 +213,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;
     }

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'
         }
     ]"
 >
@@ -85,6 +85,9 @@
         </div>
     </div>
 
+    <div class="is-status__indicator"
+         title="This item is missing or suspect"
+    ></div>
     <object-view
         ref="objectView"
         class="c-so-view__object-view"
@@ -93,7 +96,7 @@
         :object-path="objectPath"
         :layout-font-size="layoutFontSize"
         :layout-font="layoutFont"
-        @change-action-collection="setActionCollection"
+        @change-provider="setViewProvider"
     />
 </div>
 </template>
@@ -146,10 +149,15 @@ export default {
 
         let complexContent = !SIMPLE_CONTENT_TYPES.includes(this.domainObject.type);
 
+        let viewProvider = {};
+
+        let statusBarItems = {};
+
         return {
             cssClass,
             complexContent,
-            statusBarItems: [],
+            viewProvider,
+            statusBarItems,
             status: ''
         };
     },
@@ -196,7 +204,6 @@ export default {
         },
         getPreviewHeader() {
             const domainObject = this.objectPath[0];
-            const actionCollection = this.actionCollection;
             const preview = new Vue({
                 components: {
                     PreviewHeader
@@ -207,11 +214,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 +225,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,7 +253,15 @@ 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) {

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();
 

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,22 @@
             }
         }
 
-        &[class*='is-status'] {
-            border: $borderMissing;
+        &.is-status--missing {
+            @include isMissing($absPos: true);
+
+            .is-status__indicator {
+                top: $interiorMargin;
+                left: $interiorMargin;
+            }
+        }
+
+        &.is-status--suspect {
+            @include isSuspect($absPos: true);
+
+            .is-status__indicator {
+                top: $interiorMargin;
+                left: $interiorMargin;
+            }
         }
     }
 
@@ -146,6 +158,10 @@
         border: $borderMissing;
     }
 
+    &.is-status--suspect {
+        border: $borderMissing;
+    }
+
     &__object-view {
         display: flex;
         flex: 1 1 auto;
@@ -162,5 +178,4 @@
     // This element is the recipient for object styling; cannot be display: contents
     flex: 1 1 auto;
     overflow: hidden;
-    display: block;
 }

src/ui/components/object-label.scss

@@ -19,31 +19,30 @@
         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-status--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__indicator {
+            right: -3px;
+            top: -3px;
+            transform: scale(0.7);
         }
     }
 
-    &.is-status--notebook-default {
-        &:after {
-            content: $glyph-icon-notebook-page;
-            display: block;
-            margin-left: $interiorMargin;
+    &.is-status--suspect {
+        @include isSuspect($absPos: true);
+
+        .is-status__indicator {
+            right: -3px;
+            top: -3px;
+            transform: scale(0.7);
         }
     }
 }

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-status--missing': isMissing }"
     >
         <div class="c-object-label__type-icon"
              :class="typeCssClass"
         >
             <span class="is-status__indicator"
-                  :title="`This item is ${status}`"
+                  title="This item is missing or suspect"
             ></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;
         }
     }
 };

src/ui/inspector/styles/FontStyleEditor.vue

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