Changed error logging from console.log to console.warn

* If there is a pending create request for an id, queue a duplicate request.
* Hide independent time conductor mode if there is only 1 mode available

.circleci/config.yml

@@ -13,27 +13,24 @@ jobs:
         type: string
       browser:
         type: string
+      always-pass:
+        type: boolean  
     executor: linux
     steps:
       - checkout
       - restore_cache:
           key: deps-{{ .Branch }}--<< parameters.node-version >>--{{ checksum "package.json" }}
       - node/install:
-          install-npm: false
           node-version: << parameters.node-version >>
-      - run: npm install
-      - when:
+      - node/install-packages:
+          override-ci-command: npm install
+      - when: # Just to save time until caching saves the browser bin
           condition:
             equal: [ "FirefoxESR", <<parameters.browser>> ]
           steps:
             - browser-tools/install-firefox:
-                version: "91.2.0esr" #https://archive.mozilla.org/pub/firefox/releases/          
-      - when:
-          condition:
-            equal: [ "Firefox", <<parameters.browser>> ]
-          steps:
-            - browser-tools/install-firefox
-      - when:
+                version: "78.11.0esr" #https://archive.mozilla.org/pub/firefox/releases/          
+      - when: # Just to save time until caching saves the browser bin
           condition:
             equal: [ "ChromeHeadless", <<parameters.browser>> ]
           steps:
@@ -45,53 +42,46 @@ jobs:
             - ~/.npm
             - ~/.cache
             - node_modules
-      - when:
-          condition:
-            equal: [ "", <<parameters.browser>> ] #Only run linting when browsers are not running to save time
-          steps:
-            - run: npm run lint
-      - when:
-          condition: << parameters.browser >> #Truthy evaluation to only run when browser is specified
-          steps:
-            - run: npm run test:coverage -- --browsers=<<parameters.browser>>
-            - store_test_results:
-                path: dist/reports/tests/
-            - store_artifacts:
-                path: dist/reports/
+      - run: npm run test:coverage -- --browsers=<<parameters.browser>> || <<parameters.always-pass>>
+      - store_test_results:
+          path: dist/reports/tests/
+      - store_artifacts:
+          path: dist/reports/
 workflows:
   matrix-tests:
     jobs:
       - test:
-          post-steps:
-            - run:
-                command:
-                  curl -Os https://uploader.codecov.io/latest/linux/codecov;chmod +x codecov;./codecov              
           name: node10-chrome
           node-version: lts/dubnium
           browser: ChromeHeadless
+          always-pass: false
       - test:
-          name: node12-build-only
+          name: node12-firefoxESR-build-only
           node-version: lts/erbium
-          browser: "" #Skip testing
-      - test: 
-          name: node14-build-only
+          browser: FirefoxESR
+          always-pass: true
+      - test:
+          name: node14-chrome-build-only
           node-version: lts/fermium
-          browser: "" #Skip testing
-
+          browser: ChromeHeadless
+          always-pass: true
   nightly:
     jobs:
       - test:
           name: node10-chrome-nightly
           node-version: lts/dubnium
           browser: ChromeHeadless
+          always-pass: false
       - test:
           name: node12-firefoxESR-nightly
           node-version: lts/erbium
           browser: FirefoxESR
+          always-pass: false
       - test:
-          name: node14-firefox-nightly
+          name: node14-chrome-nightly
           node-version: lts/fermium
-          browser: Firefox
+          browser: ChromeHeadless
+          always-pass: false
     triggers:
       - schedule:
           cron: "0 0 * * *"

.github/PULL_REQUEST_TEMPLATE.md

@@ -2,7 +2,6 @@
 
 * [ ] Have you followed the guidelines in our [Contributing document](https://github.com/nasa/openmct/blob/master/CONTRIBUTING.md)?
 * [ ] Have you checked to ensure there aren't other open [Pull Requests](https://github.com/nasa/openmct/pulls) for the same update/change?
-* [ ] Is this change backwards compatible? For example, developers won't need to change how they are calling the API or how they've extended core plugins such as Tables or Plots.
 
 ### Author Checklist
 

.github/dependabot.yml

@@ -1,23 +0,0 @@
-
-version: 2
-updates:
-  - package-ecosystem: "npm"
-    directory: "/"
-    schedule:
-      interval: "daily"  
-    open-pull-requests-limit: 2
-    labels:
-      - "type:maintenance"
-      - "dependencies"
-    allow:
-      - dependency-name: "eslint*"
-      - dependency-name: "karma*"
-      - dependency-name: "jasmine*"
-
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: "daily"    
-    labels:
-      - "type:maintenance"
-      - "dependencies"

.github/workflows/codeql-analysis.yml

@@ -4,14 +4,6 @@ name: "CodeQL"
 on:
   push:
     branches: [ master ]
-  pull_request:
-    branches: [ master ]
-    paths-ignore:
-      - '**/*Spec.js'
-      - '**/*.md'
-      - '**/*.txt'
-      - '**/*.yml'
-      - '**/*.yaml'
   schedule:
     - cron: '28 21 * * 3'
 

.gitignore

@@ -44,6 +44,3 @@ report.*.json
 .lighthouseci
 
 package-lock.json
-
-#codecov artifacts
-codecov

CONTRIBUTING.md

@@ -317,7 +317,6 @@ checklist).
 ### Reviewer Checklist
 
 * [ ] Changes appear to address issue?
-* [ ] Changes appear not to be breaking changes?
 * [ ] Appropriate unit tests included?
 * [ ] Code style and in-line documentation are appropriate?
 * [ ] Commit messages meet standards?

README.md

@@ -1,4 +1,4 @@
-# Open MCT [![license](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](http://www.apache.org/licenses/LICENSE-2.0) [![Language grade: JavaScript](https://img.shields.io/lgtm/grade/javascript/g/nasa/openmct.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/nasa/openmct/context:javascript) [![codecov](https://codecov.io/gh/nasa/openmct/branch/master/graph/badge.svg?token=7DQIipp3ej)](https://codecov.io/gh/nasa/openmct)
+# Open MCT [![license](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](http://www.apache.org/licenses/LICENSE-2.0) [![Language grade: JavaScript](https://img.shields.io/lgtm/grade/javascript/g/nasa/openmct.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/nasa/openmct/context:javascript)
 
 Open MCT (Open Mission Control Technologies) is a next-generation mission control framework for visualization of data on desktop and mobile devices. It is developed at NASA's Ames Research Center, and is being used by NASA for data analysis of spacecraft missions, as well as planning and operation of experimental rover systems. As a generalizable and open source framework, Open MCT could be used as the basis for building applications for planning, operation, and analysis of any systems producing telemetry data.
 
@@ -85,8 +85,6 @@ naming convention is otherwise the same.)
 When `npm test` is run, test results will be written as HTML to
 `dist/reports/tests/`. Code coverage information is written to `dist/reports/coverage`.
 
-Code Coverage Reports are available from [codecov.io](https://app.codecov.io/gh/nasa/openmct/)
-
 # Glossary
 
 Certain terms are used throughout Open MCT with consistent meanings

codecov.yml

@@ -1,15 +0,0 @@
-codecov:
-  require_ci_to_pass: true
-
-status:
-  project:
-    default:
-      informational: true
-  patch:
-    default:
-      informational: true
-
-comment:
-  layout: "reach,diff,flags,files,footer"
-  behavior: default
-  require_changes: false

example/generator/GeneratorMetadataProvider.js

@@ -118,6 +118,100 @@ define([
                     }
                 }
             ]
+        },
+        'example.spectral-generator': {
+            values: [
+                {
+                    key: "name",
+                    name: "Name",
+                    format: "string"
+                },
+                {
+                    key: "utc",
+                    name: "Time",
+                    format: "utc",
+                    hints: {
+                        domain: 1
+                    }
+                },
+                {
+                    key: "wavelength",
+                    name: "Wavelength",
+                    unit: "Hz",
+                    formatString: '%0.2f',
+                    hints: {
+                        domain: 2,
+                        spectralAttribute: true
+                    }
+                },
+                {
+                    key: "cos",
+                    name: "Cosine",
+                    unit: "deg",
+                    formatString: '%0.2f',
+                    hints: {
+                        range: 2,
+                        spectralAttribute: true
+                    }
+                }
+            ]
+        },
+        'example.spectral-aggregate-generator': {
+            values: [
+                {
+                    key: "name",
+                    name: "Name",
+                    format: "string"
+                },
+                {
+                    key: "utc",
+                    name: "Time",
+                    format: "utc",
+                    hints: {
+                        domain: 1
+                    }
+                },
+                {
+                    key: "ch1",
+                    name: "Channel 1",
+                    format: "string",
+                    hints: {
+                        range: 1
+                    }
+                },
+                {
+                    key: "ch2",
+                    name: "Channel 2",
+                    format: "string",
+                    hints: {
+                        range: 2
+                    }
+                },
+                {
+                    key: "ch3",
+                    name: "Channel 3",
+                    format: "string",
+                    hints: {
+                        range: 3
+                    }
+                },
+                {
+                    key: "ch4",
+                    name: "Channel 4",
+                    format: "string",
+                    hints: {
+                        range: 4
+                    }
+                },
+                {
+                    key: "ch5",
+                    name: "Channel 5",
+                    format: "string",
+                    hints: {
+                        range: 5
+                    }
+                }
+            ]
         }
     };
 

example/generator/SpectralAggregateGeneratorProvider.js

@@ -0,0 +1,86 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, 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 (
+
+) {
+
+    function SpectralAggregateGeneratorProvider() {
+
+    }
+
+    function pointForTimestamp(timestamp, count, name) {
+        return {
+            name: name,
+            utc: String(Math.floor(timestamp / count) * count),
+            ch1: String(Math.floor(timestamp / count) % 1),
+            ch2: String(Math.floor(timestamp / count) % 2),
+            ch3: String(Math.floor(timestamp / count) % 3),
+            ch4: String(Math.floor(timestamp / count) % 4),
+            ch5: String(Math.floor(timestamp / count) % 5)
+        };
+    }
+
+    SpectralAggregateGeneratorProvider.prototype.supportsSubscribe = function (domainObject) {
+        return domainObject.type === 'example.spectral-aggregate-generator';
+    };
+
+    SpectralAggregateGeneratorProvider.prototype.subscribe = function (domainObject, callback) {
+        var count = 5000;
+
+        var interval = setInterval(function () {
+            var now = Date.now();
+            var datum = pointForTimestamp(now, count, domainObject.name);
+            callback(datum);
+        }, count);
+
+        return function () {
+            clearInterval(interval);
+        };
+    };
+
+    SpectralAggregateGeneratorProvider.prototype.supportsRequest = function (domainObject, options) {
+        return domainObject.type === 'example.spectral-aggregate-generator';
+    };
+
+    SpectralAggregateGeneratorProvider.prototype.request = function (domainObject, options) {
+        var start = options.start;
+        var end = Math.min(Date.now(), options.end); // no future values
+        var count = 5000;
+        if (options.strategy === 'latest' || options.size === 1) {
+            start = end;
+        }
+
+        var data = [];
+        while (start <= end && data.length < 5000) {
+            data.push(pointForTimestamp(start, count, domainObject.name));
+            start += count;
+        }
+
+        return Promise.resolve(data);
+    };
+
+    return SpectralAggregateGeneratorProvider;
+
+});

example/generator/SpectralGeneratorProvider.js

@@ -0,0 +1,102 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, 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([
+    './WorkerInterface'
+], function (
+    WorkerInterface
+) {
+
+    var REQUEST_DEFAULTS = {
+        amplitude: 1,
+        wavelength: 1,
+        period: 10,
+        offset: 0,
+        dataRateInHz: 1,
+        randomness: 0,
+        phase: 0
+    };
+
+    function SpectralGeneratorProvider() {
+        this.workerInterface = new WorkerInterface();
+    }
+
+    SpectralGeneratorProvider.prototype.canProvideTelemetry = function (domainObject) {
+        return domainObject.type === 'example.spectral-generator';
+    };
+
+    SpectralGeneratorProvider.prototype.supportsRequest =
+        SpectralGeneratorProvider.prototype.supportsSubscribe =
+            SpectralGeneratorProvider.prototype.canProvideTelemetry;
+
+    SpectralGeneratorProvider.prototype.makeWorkerRequest = function (domainObject, request = {}) {
+        var props = [
+            'amplitude',
+            'wavelength',
+            'period',
+            'offset',
+            'dataRateInHz',
+            'phase',
+            'randomness'
+        ];
+
+        var workerRequest = {};
+
+        props.forEach(function (prop) {
+            if (domainObject.telemetry && Object.prototype.hasOwnProperty.call(domainObject.telemetry, prop)) {
+                workerRequest[prop] = domainObject.telemetry[prop];
+            }
+
+            if (request && Object.prototype.hasOwnProperty.call(request, prop)) {
+                workerRequest[prop] = request[prop];
+            }
+
+            if (!Object.prototype.hasOwnProperty.call(workerRequest, prop)) {
+                workerRequest[prop] = REQUEST_DEFAULTS[prop];
+            }
+
+            workerRequest[prop] = Number(workerRequest[prop]);
+        });
+
+        workerRequest.name = domainObject.name;
+
+        return workerRequest;
+    };
+
+    SpectralGeneratorProvider.prototype.request = function (domainObject, request) {
+        var workerRequest = this.makeWorkerRequest(domainObject, request);
+        workerRequest.start = request.start;
+        workerRequest.end = request.end;
+        workerRequest.spectra = true;
+
+        return this.workerInterface.request(workerRequest);
+    };
+
+    SpectralGeneratorProvider.prototype.subscribe = function (domainObject, callback) {
+        var workerRequest = this.makeWorkerRequest(domainObject, {});
+        workerRequest.spectra = true;
+
+        return this.workerInterface.subscribe(workerRequest, callback);
+    };
+
+    return SpectralGeneratorProvider;
+});

example/generator/plugin.js

@@ -24,11 +24,15 @@ define([
     "./GeneratorProvider",
     "./SinewaveLimitProvider",
     "./StateGeneratorProvider",
+    "./SpectralGeneratorProvider",
+    "./SpectralAggregateGeneratorProvider",
     "./GeneratorMetadataProvider"
 ], function (
     GeneratorProvider,
     SinewaveLimitProvider,
     StateGeneratorProvider,
+    SpectralGeneratorProvider,
+    SpectralAggregateGeneratorProvider,
     GeneratorMetadataProvider
 ) {
 
@@ -61,6 +65,37 @@ define([
 
         openmct.telemetry.addProvider(new StateGeneratorProvider());
 
+        openmct.types.addType("example.spectral-generator", {
+            name: "Spectral Generator",
+            description: "For development use. Generates example streaming telemetry data using a simple sine wave algorithm.",
+            cssClass: "icon-generator-telemetry",
+            creatable: true,
+            initialize: function (object) {
+                object.telemetry = {
+                    period: 10,
+                    amplitude: 1,
+                    wavelength: 1,
+                    frequency: 1,
+                    offset: 0,
+                    dataRateInHz: 1,
+                    phase: 0,
+                    randomness: 0
+                };
+            }
+        });
+        openmct.telemetry.addProvider(new SpectralGeneratorProvider());
+
+        openmct.types.addType("example.spectral-aggregate-generator", {
+            name: "Spectral Aggregate Generator",
+            description: "For development use. Generates example streaming telemetry data using a simple state algorithm.",
+            cssClass: "icon-generator-telemetry",
+            creatable: true,
+            initialize: function (object) {
+                object.telemetry = {};
+            }
+        });
+        openmct.telemetry.addProvider(new SpectralAggregateGeneratorProvider());
+
         openmct.types.addType("generator", {
             name: "Sine Wave Generator",
             description: "For development use. Generates example streaming telemetry data using a simple sine wave algorithm.",

karma.conf.js

@@ -25,7 +25,7 @@
 const devMode = process.env.NODE_ENV !== 'production';
 const browsers = [process.env.NODE_ENV === 'debug' ? 'ChromeDebugging' : 'ChromeHeadless'];
 const coverageEnabled = process.env.COVERAGE === 'true';
-const reporters = ['spec', 'junit'];
+const reporters = ['progress', 'html', 'junit'];
 
 if (coverageEnabled) {
     reporters.push('coverage-istanbul');
@@ -60,7 +60,7 @@ module.exports = (config) => {
         client: {
             jasmine: {
                 random: false,
-                timeoutInterval: 5000
+                timeoutInterval: 30000
             }
         },
         customLaunchers: {
@@ -78,37 +78,33 @@ module.exports = (config) => {
         logLevel: config.LOG_INFO,
         autoWatch: true,
         // HTML test reporting.
-        // htmlReporter: {
-        //    outputDir: "dist/reports/tests",
-        //    preserveDescribeNesting: true,
-        //    foldAll: false
-        // },
+        htmlReporter: {
+            outputDir: "dist/reports/tests",
+            preserveDescribeNesting: true,
+            foldAll: false
+        },
         junitReporter: {
             outputDir: "dist/reports/tests",
             outputFile: "test-results.xml",
             useBrowserName: false
         },
+        browserConsoleLogOptions: {
+            level: "error",
+            format: "%b %T: %m",
+            terminal: true
+        },
         coverageIstanbulReporter: {
             fixWebpackSourcePaths: true,
             dir: process.env.CIRCLE_ARTIFACTS
                 ? process.env.CIRCLE_ARTIFACTS + '/coverage'
                 : "dist/reports/coverage",
-            reports: ['lcovonly', 'text-summary'],
+            reports: ['html', 'lcovonly', 'text-summary'],
             thresholds: {
                 global: {
                     lines: 66
                 }
             }
         },
-        specReporter: {
-            maxLogLines: 5,
-            suppressErrorSummary: true,
-            suppressFailed: false,
-            suppressPassed: false,
-            suppressSkipped: true,
-            showSpecTiming: true,
-            failFast: false
-        },
         preprocessors: {
             'indexTest.js': ['webpack', 'sourcemap']
         },

package.json

@@ -1,9 +1,8 @@
 {
   "name": "openmct",
-  "version": "1.8.1-SNAPSHOT",
+  "version": "1.7.8-SNAPSHOT",
   "description": "The Open MCT core platform",
   "devDependencies": {
-    "@braintree/sanitize-url": "^5.0.2",
     "angular": ">=1.8.0",
     "angular-route": "1.4.14",
     "babel-eslint": "10.0.3",
@@ -38,10 +37,10 @@
     "karma-coverage": "2.0.3",
     "karma-coverage-istanbul-reporter": "3.0.3",
     "karma-firefox-launcher": "2.1.1",
+    "karma-html-reporter": "0.2.7",
     "karma-jasmine": "4.0.1",
     "karma-junit-reporter": "2.0.1",
     "karma-sourcemap-loader": "0.3.8",
-    "karma-spec-reporter": "0.0.32",
     "karma-webpack": "4.0.2",
     "location-bar": "^3.0.1",
     "lodash": "^4.17.12",
@@ -65,7 +64,6 @@
     "uuid": "^3.3.3",
     "v8-compile-cache": "^1.1.0",
     "vue": "2.5.6",
-    "vue-eslint-parser": "7.11.0",
     "vue-loader": "^15.2.6",
     "vue-template-compiler": "2.5.6",
     "webpack": "^4.16.2",

platform/commonUI/edit/bundle.js

@@ -34,6 +34,9 @@ define([
     "./src/policies/EditPersistableObjectsPolicy",
     "./src/representers/EditRepresenter",
     "./src/capabilities/EditorCapability",
+    "./src/capabilities/TransactionCapabilityDecorator",
+    "./src/services/TransactionManager",
+    "./src/services/TransactionService",
     "./src/creation/CreateMenuController",
     "./src/creation/LocatorController",
     "./src/creation/CreationPolicy",
@@ -60,6 +63,9 @@ define([
     EditPersistableObjectsPolicy,
     EditRepresenter,
     EditorCapability,
+    TransactionCapabilityDecorator,
+    TransactionManager,
+    TransactionService,
     CreateMenuController,
     LocatorController,
     CreationPolicy,
@@ -257,6 +263,26 @@ define([
                     }
                 ],
                 "components": [
+                    {
+                        "type": "decorator",
+                        "provides": "capabilityService",
+                        "implementation": TransactionCapabilityDecorator,
+                        "depends": [
+                            "$q",
+                            "transactionManager"
+                        ],
+                        "priority": "fallback"
+                    },
+                    {
+                        "type": "provider",
+                        "provides": "transactionService",
+                        "implementation": TransactionService,
+                        "depends": [
+                            "$q",
+                            "$log",
+                            "cacheService"
+                        ]
+                    },
                     {
                         "key": "CreateActionProvider",
                         "provides": "actionService",
@@ -294,6 +320,7 @@ define([
                         "description": "Provides transactional editing capabilities",
                         "implementation": EditorCapability,
                         "depends": [
+                            "transactionService",
                             "openmct"
                         ]
                     }
@@ -304,6 +331,15 @@ define([
                         "template": locatorTemplate
                     }
                 ],
+                "services": [
+                    {
+                        "key": "transactionManager",
+                        "implementation": TransactionManager,
+                        "depends": [
+                            "transactionService"
+                        ]
+                    }
+                ],
                 "runs": [
                     {
                         depends: [

platform/commonUI/edit/src/actions/SaveAsAction.js

@@ -96,7 +96,8 @@ function (
     SaveAsAction.prototype.save = function () {
         var self = this,
             domainObject = this.domainObject,
-            dialog = new SaveInProgressDialog(this.dialogService);
+            dialog = new SaveInProgressDialog(this.dialogService),
+            toUndirty = [];
 
         function doWizardSave(parent) {
             var wizard = self.createWizard(parent);
@@ -131,14 +132,11 @@ function (
             return fetchObject(object.getModel().location);
         }
 
-        function saveObject(object) {
-            //persist the object, which adds it to the transaction and then call editor.save
-            return object.getCapability("persistence").persist()
-                .then(() => {
-                    return self.openmct.editor.save().then(() => {
-                        return object;
-                    });
-                });
+        function saveObject(parent) {
+            return self.openmct.editor.save().then(() => {
+                // Force mutation for search indexing
+                return parent;
+            });
         }
 
         function addSavedObjectToParent(parent) {
@@ -152,6 +150,17 @@ function (
                 });
         }
 
+        function undirty(object) {
+            return object.getCapability('persistence').refresh();
+        }
+
+        function undirtyOriginals(object) {
+            return Promise.all(toUndirty.map(undirty))
+                .then(() => {
+                    return object;
+                });
+        }
+
         function indexForSearch(addedObject) {
             addedObject.useCapability('mutation', (model) => {
                 return model;
@@ -178,9 +187,10 @@ function (
         return getParent(domainObject)
             .then(doWizardSave)
             .then(showBlockingDialog)
-            .then(saveObject)
             .then(getParent)
+            .then(saveObject)
             .then(addSavedObjectToParent)
+            .then(undirtyOriginals)
             .then((addedObject) => {
                 return fetchObject(addedObject.getId());
             })

platform/commonUI/edit/src/capabilities/EditorCapability.js

@@ -30,17 +30,34 @@ define(
          * Once initiated, any persist operations will be queued pending a
          * subsequent call to [.save()](@link #save) or [.finish()](@link
          * #finish).
+         * @param transactionService
          * @param domainObject
          * @constructor
          */
         function EditorCapability(
+            transactionService,
             openmct,
             domainObject
         ) {
+            this.transactionService = transactionService;
             this.openmct = openmct;
             this.domainObject = domainObject;
         }
 
+        /**
+         * Initiate an editing session. This will start a transaction during
+         * which any persist operations will be deferred until either save()
+         * or finish() are called.
+         */
+        EditorCapability.prototype.edit = function () {
+            console.warn('DEPRECATED: cannot edit via edit capability, use openmct.editor instead.');
+
+            if (!this.openmct.editor.isEditing()) {
+                this.openmct.editor.edit();
+                this.domainObject.getCapability('status').set('editing', true);
+            }
+        };
+
         /**
          * Determines whether this object, or any of its ancestors are
          * currently being edited.
@@ -59,6 +76,38 @@ define(
             return this.openmct.editor.isEditing();
         };
 
+        /**
+         * Save any unsaved changes from this editing session. This will
+         * end the current transaction and continue with a new one.
+         * @returns {*}
+         */
+        EditorCapability.prototype.save = function () {
+            console.warn('DEPRECATED: cannot save via edit capability, use openmct.editor instead.');
+
+            return Promise.resolve();
+        };
+
+        EditorCapability.prototype.invoke = EditorCapability.prototype.edit;
+
+        /**
+         * Finish the current editing session. This will discard any pending
+         * persist operations
+         * @returns {*}
+         */
+        EditorCapability.prototype.finish = function () {
+            console.warn('DEPRECATED: cannot finish via edit capability, use openmct.editor instead.');
+
+            return Promise.resolve();
+        };
+
+        /**
+         * @returns {boolean} true if there have been any domain model
+         * modifications since the last persist, false otherwise.
+         */
+        EditorCapability.prototype.dirty = function () {
+            return this.transactionService.size() > 0;
+        };
+
         return EditorCapability;
     }
 );

platform/commonUI/edit/src/capabilities/TransactionCapabilityDecorator.js

@@ -0,0 +1,75 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, 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(
+    ['./TransactionalPersistenceCapability'],
+    function (TransactionalPersistenceCapability) {
+
+        /**
+         * Wraps the [PersistenceCapability]{@link PersistenceCapability} with
+         * transactional capabilities.
+         * @param $q
+         * @param transactionService
+         * @param capabilityService
+         * @see TransactionalPersistenceCapability
+         * @constructor
+         */
+        function TransactionCapabilityDecorator(
+            $q,
+            transactionService,
+            capabilityService
+        ) {
+            this.capabilityService = capabilityService;
+            this.transactionService = transactionService;
+            this.$q = $q;
+        }
+
+        /**
+         * Decorate PersistenceCapability to queue persistence calls when a
+         * transaction is in progress.
+         */
+        TransactionCapabilityDecorator.prototype.getCapabilities = function () {
+            var self = this,
+                capabilities = this.capabilityService.getCapabilities
+                    .apply(this.capabilityService, arguments),
+                persistenceCapability = capabilities.persistence;
+
+            capabilities.persistence = function (domainObject) {
+                var original =
+                    (typeof persistenceCapability === 'function')
+                        ? persistenceCapability(domainObject)
+                        : persistenceCapability;
+
+                return new TransactionalPersistenceCapability(
+                    self.$q,
+                    self.transactionService,
+                    original,
+                    domainObject
+                );
+            };
+
+            return capabilities;
+        };
+
+        return TransactionCapabilityDecorator;
+    }
+);

platform/commonUI/edit/src/capabilities/TransactionalPersistenceCapability.js

@@ -0,0 +1,91 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, 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 () {
+
+        /**
+         * Wraps persistence capability to enable transactions. Transactions
+         * will cause persist calls not to be invoked immediately, but
+         * rather queued until [EditorCapability.save()]{@link EditorCapability#save}
+         * or [EditorCapability.cancel()]{@link EditorCapability#cancel} are
+         * called.
+         * @memberof platform/commonUI/edit/capabilities
+         * @param $q
+         * @param transactionManager
+         * @param persistenceCapability
+         * @param domainObject
+         * @constructor
+         */
+        function TransactionalPersistenceCapability(
+            $q,
+            transactionManager,
+            persistenceCapability,
+            domainObject
+        ) {
+            this.transactionManager = transactionManager;
+            this.persistenceCapability = persistenceCapability;
+            this.domainObject = domainObject;
+            this.$q = $q;
+        }
+
+        /**
+         * The wrapped persist function. If a transaction is active, persist
+         * will be queued until the transaction is committed or cancelled.
+         * @returns {*}
+         */
+        TransactionalPersistenceCapability.prototype.persist = function () {
+            var wrappedPersistence = this.persistenceCapability;
+
+            if (this.transactionManager.isActive()) {
+                this.transactionManager.addToTransaction(
+                    this.domainObject.getId(),
+                    wrappedPersistence.persist.bind(wrappedPersistence),
+                    wrappedPersistence.refresh.bind(wrappedPersistence)
+                );
+
+                //Need to return a promise from this function
+                return this.$q.when(true);
+            } else {
+                return this.persistenceCapability.persist();
+            }
+        };
+
+        TransactionalPersistenceCapability.prototype.refresh = function () {
+            this.transactionManager
+                .clearTransactionsFor(this.domainObject.getId());
+
+            return this.persistenceCapability.refresh();
+        };
+
+        TransactionalPersistenceCapability.prototype.getSpace = function () {
+            return this.persistenceCapability.getSpace();
+        };
+
+        TransactionalPersistenceCapability.prototype.persisted = function () {
+            return this.persistenceCapability.persisted();
+        };
+
+        return TransactionalPersistenceCapability;
+    }
+);

platform/commonUI/edit/src/services/NestedTransaction.js

@@ -19,10 +19,31 @@
  * this source code distribution or the Licensing information page available
  * at runtime from the About dialog for additional information.
  *****************************************************************************/
+define(['./Transaction'], function (Transaction) {
+    /**
+     * A nested transaction is a transaction which takes place in the context
+     * of a larger parent transaction. It becomes part of the parent
+     * transaction when (and only when) committed.
+     * @param parent
+     * @constructor
+     * @extends {platform/commonUI/edit/services.Transaction}
+     * @memberof platform/commonUI/edit/services
+     */
+    function NestedTransaction(parent) {
+        this.parent = parent;
+        Transaction.call(this, parent.$log);
+    }
 
-const PRIORITIES = Object.freeze({
-    HIGH: 1000,
-    DEFAULT: 0,
-    LOW: -1000
+    NestedTransaction.prototype = Object.create(Transaction.prototype);
+
+    NestedTransaction.prototype.commit = function () {
+        this.parent.add(
+            Transaction.prototype.commit.bind(this),
+            Transaction.prototype.cancel.bind(this)
+        );
+
+        return Promise.resolve(true);
+    };
+
+    return NestedTransaction;
 });
-export default PRIORITIES;

platform/commonUI/edit/src/services/Transaction.js

@@ -0,0 +1,99 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, 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 () {
+    /**
+     * A Transaction represents a set of changes that are intended to
+     * be kept or discarded as a unit.
+     * @param $log Angular's `$log` service, for logging messages
+     * @constructor
+     * @memberof platform/commonUI/edit/services
+     */
+    function Transaction($log) {
+        this.$log = $log;
+        this.callbacks = [];
+    }
+
+    /**
+     * Add a change to the current transaction, as expressed by functions
+     * to either keep or discard the change.
+     * @param {Function} commit called when the transaction is committed
+     * @param {Function} cancel called when the transaction is cancelled
+     * @returns {Function) a function which may be called to remove this
+     *          pair of callbacks from the transaction
+     */
+    Transaction.prototype.add = function (commit, cancel) {
+        var callback = {
+            commit: commit,
+            cancel: cancel
+        };
+        this.callbacks.push(callback);
+
+        return function () {
+            this.callbacks = this.callbacks.filter(function (c) {
+                return c !== callback;
+            });
+        }.bind(this);
+    };
+
+    /**
+     * Get the number of changes in the current transaction.
+     * @returns {number} the size of the current transaction
+     */
+    Transaction.prototype.size = function () {
+        return this.callbacks.length;
+    };
+
+    /**
+     * Keep all changes associated with this transaction.
+     * @method {platform/commonUI/edit/services.Transaction#commit}
+     * @returns {Promise} a promise which will resolve when all callbacks
+     *          have been handled.
+     */
+
+    /**
+     * Discard all changes associated with this transaction.
+     * @method {platform/commonUI/edit/services.Transaction#cancel}
+     * @returns {Promise} a promise which will resolve when all callbacks
+     *          have been handled.
+     */
+
+    ['commit', 'cancel'].forEach(function (method) {
+        Transaction.prototype[method] = function () {
+            var promises = [];
+            var callback;
+
+            while (this.callbacks.length > 0) {
+                callback = this.callbacks.shift();
+                try {
+                    promises.push(callback[method]());
+                } catch (e) {
+                    this.$log
+                        .error("Error trying to " + method + " transaction.");
+                }
+            }
+
+            return Promise.all(promises);
+        };
+    });
+
+    return Transaction;
+});

platform/commonUI/edit/src/services/TransactionManager.js

@@ -0,0 +1,119 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, 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 () {
+    /**
+     * Manages transactions to support the TransactionalPersistenceCapability.
+     * This assumes that all commit/cancel callbacks for a given domain
+     * object are equivalent, and only need to be added once to any active
+     * transaction. Violating this assumption may cause unexpected behavior.
+     * @constructor
+     * @memberof platform/commonUI/edit
+     */
+    function TransactionManager(transactionService) {
+        this.transactionService = transactionService;
+        this.clearTransactionFns = {};
+    }
+
+    /**
+     * Check if a transaction is currently active.
+     * @returns {boolean} true if there is a transaction active
+     */
+    TransactionManager.prototype.isActive = function () {
+        return this.transactionService.isActive();
+    };
+
+    /**
+     * Check if callbacks associated with this domain object have already
+     * been added to the active transaction.
+     * @private
+     * @param {string} id the identifier of the domain object to check
+     * @returns {boolean} true if callbacks have been added
+     */
+    TransactionManager.prototype.isScheduled = function (id) {
+        return Boolean(this.clearTransactionFns[id]);
+    };
+
+    /**
+     * Add callbacks associated with this domain object to the active
+     * transaction. Both callbacks are expected to return promises that
+     * resolve when their associated behavior is complete.
+     *
+     * If callbacks associated with this domain object have already been
+     * added to the active transaction, this call will be ignored.
+     *
+     * @param {string} id the identifier of the associated domain object
+     * @param {Function} onCommit behavior to invoke when committing transaction
+     * @param {Function} onCancel behavior to invoke when cancelling transaction
+     */
+    TransactionManager.prototype.addToTransaction = function (
+        id,
+        onCommit,
+        onCancel
+    ) {
+        var release = this.releaseClearFn.bind(this, id);
+
+        function chain(promiseFn, nextFn) {
+            return function () {
+                return promiseFn().then(nextFn);
+            };
+        }
+
+        /**
+         * Clear any existing persistence calls for object with given ID. This ensures only the most recent persistence
+         * call is executed. This should prevent stale objects being persisted and overwriting fresh ones.
+         */
+        if (this.isScheduled(id)) {
+            this.clearTransactionsFor(id);
+        }
+
+        this.clearTransactionFns[id] =
+            this.transactionService.addToTransaction(
+                chain(onCommit, release),
+                chain(onCancel, release)
+            );
+    };
+
+    /**
+     * Remove any callbacks associated with this domain object from the
+     * active transaction.
+     * @param {string} id the identifier for the domain object
+     */
+    TransactionManager.prototype.clearTransactionsFor = function (id) {
+        if (this.isScheduled(id)) {
+            this.clearTransactionFns[id]();
+            this.releaseClearFn(id);
+        }
+    };
+
+    /**
+     * Release the cached "remove from transaction" function that has been
+     * stored in association with this domain object.
+     * @param {string} id the identifier for the domain object
+     * @private
+     */
+    TransactionManager.prototype.releaseClearFn = function (id) {
+        delete this.clearTransactionFns[id];
+    };
+
+    return TransactionManager;
+});

platform/commonUI/edit/src/services/TransactionService.js

@@ -0,0 +1,138 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, 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(
+    ['./Transaction', './NestedTransaction'],
+    function (Transaction, NestedTransaction) {
+        /**
+         * Implements an application-wide transaction state. Once a
+         * transaction is started, calls to
+         * [PersistenceCapability.persist()]{@link PersistenceCapability#persist}
+         * will be deferred until a subsequent call to
+         * [TransactionService.commit]{@link TransactionService#commit} is made.
+         *
+         * @memberof platform/commonUI/edit/services
+         * @param $q
+         * @constructor
+         */
+        function TransactionService($q, $log, cacheService) {
+            this.$q = $q;
+            this.$log = $log;
+            this.cacheService = cacheService;
+            this.transactions = [];
+        }
+
+        /**
+         * Starts a transaction. While a transaction is active all calls to
+         * [PersistenceCapability.persist](@link PersistenceCapability#persist)
+         * will be queued until [commit]{@link #commit} or [cancel]{@link
+         * #cancel} are called
+         */
+        TransactionService.prototype.startTransaction = function () {
+            var transaction = this.isActive()
+                ? new NestedTransaction(this.transactions[0])
+                : new Transaction(this.$log);
+
+            this.transactions.push(transaction);
+        };
+
+        /**
+         * @returns {boolean} If true, indicates that a transaction is in progress
+         */
+        TransactionService.prototype.isActive = function () {
+            return this.transactions.length > 0;
+        };
+
+        /**
+         * Adds provided functions to a queue to be called on
+         * [.commit()]{@link #commit} or
+         * [.cancel()]{@link #commit}
+         * @param onCommit A function to call on commit
+         * @param onCancel A function to call on cancel
+         */
+        TransactionService.prototype.addToTransaction = function (onCommit, onCancel) {
+            if (this.isActive()) {
+                return this.activeTransaction().add(onCommit, onCancel);
+            } else {
+                //Log error because this is a programming error if it occurs.
+                this.$log.error("No transaction in progress");
+            }
+        };
+
+        /**
+         * Get the transaction at the top of the stack.
+         * @private
+         */
+        TransactionService.prototype.activeTransaction = function () {
+            return this.transactions[this.transactions.length - 1];
+        };
+
+        /**
+         * All persist calls deferred since the beginning of the transaction
+         * will be committed.  If this is the last transaction, clears the
+         * cache.
+         *
+         * @returns {Promise} resolved when all persist operations have
+         * completed. Will reject if any commit operations fail
+         */
+        TransactionService.prototype.commit = function () {
+            var transaction = this.transactions.pop();
+            if (!transaction) {
+                return Promise.reject();
+            }
+
+            if (!this.isActive()) {
+                return transaction.commit()
+                    .then(function (r) {
+                        this.cacheService.flush();
+
+                        return r;
+                    }.bind(this));
+            }
+
+            return transaction.commit();
+        };
+
+        /**
+         * Cancel the current transaction, replacing any dirty objects from
+         * persistence. Not a true rollback, as it cannot be used to undo any
+         * persist calls that were successful in the event one of a batch of
+         * persists failing.
+         *
+         * @returns {*}
+         */
+        TransactionService.prototype.cancel = function () {
+            var transaction = this.transactions.pop();
+
+            return transaction ? transaction.cancel() : Promise.reject();
+        };
+
+        /**
+         * Get the size (the number of commit/cancel callbacks) of
+         * the active transaction.
+         * @returns {number} size of the active transaction
+         */
+        TransactionService.prototype.size = function () {
+            return this.isActive() ? this.activeTransaction().size() : 0;
+        };
+
+        return TransactionService;
+    });

platform/commonUI/edit/test/capabilities/EditorCapabilitySpec.js

@@ -0,0 +1,192 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, 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/capabilities/EditorCapability"],
+    function (EditorCapability) {
+
+        xdescribe("The editor capability", function () {
+            var mockDomainObject,
+                capabilities,
+                mockParentObject,
+                mockTransactionService,
+                mockStatusCapability,
+                mockParentStatus,
+                mockContextCapability,
+                capability;
+
+            function fastPromise(val) {
+                return {
+                    then: function (callback) {
+                        return callback(val);
+                    }
+                };
+            }
+
+            beforeEach(function () {
+                mockDomainObject = jasmine.createSpyObj(
+                    "domainObject",
+                    ["getId", "getModel", "hasCapability", "getCapability", "useCapability"]
+                );
+                mockParentObject = jasmine.createSpyObj(
+                    "domainObject",
+                    ["getId", "getModel", "hasCapability", "getCapability", "useCapability"]
+                );
+                mockTransactionService = jasmine.createSpyObj(
+                    "transactionService",
+                    [
+                        "startTransaction",
+                        "size",
+                        "commit",
+                        "cancel"
+                    ]
+                );
+                mockTransactionService.commit.and.returnValue(fastPromise());
+                mockTransactionService.cancel.and.returnValue(fastPromise());
+                mockTransactionService.isActive = jasmine.createSpy('isActive');
+
+                mockStatusCapability = jasmine.createSpyObj(
+                    "statusCapability",
+                    ["get", "set"]
+                );
+                mockParentStatus = jasmine.createSpyObj(
+                    "statusCapability",
+                    ["get", "set"]
+                );
+                mockContextCapability = jasmine.createSpyObj(
+                    "contextCapability",
+                    ["getParent"]
+                );
+                mockContextCapability.getParent.and.returnValue(mockParentObject);
+
+                capabilities = {
+                    context: mockContextCapability,
+                    status: mockStatusCapability
+                };
+
+                mockDomainObject.hasCapability.and.callFake(function (name) {
+                    return capabilities[name] !== undefined;
+                });
+
+                mockDomainObject.getCapability.and.callFake(function (name) {
+                    return capabilities[name];
+                });
+
+                mockParentObject.getCapability.and.returnValue(mockParentStatus);
+                mockParentObject.hasCapability.and.returnValue(false);
+
+                capability = new EditorCapability(
+                    mockTransactionService,
+                    mockDomainObject
+                );
+            });
+
+            it("starts a transaction when edit is invoked", function () {
+                capability.edit();
+                expect(mockTransactionService.startTransaction).toHaveBeenCalled();
+            });
+
+            it("sets editing status on object", function () {
+                capability.edit();
+                expect(mockStatusCapability.set).toHaveBeenCalledWith("editing", true);
+            });
+
+            it("uses editing status to determine editing context root", function () {
+                capability.edit();
+                mockStatusCapability.get.and.returnValue(false);
+                expect(capability.isEditContextRoot()).toBe(false);
+                mockStatusCapability.get.and.returnValue(true);
+                expect(capability.isEditContextRoot()).toBe(true);
+            });
+
+            it("inEditingContext returns true if parent object is being"
+                + " edited", function () {
+                mockStatusCapability.get.and.returnValue(false);
+                mockParentStatus.get.and.returnValue(false);
+                expect(capability.inEditContext()).toBe(false);
+                mockParentStatus.get.and.returnValue(true);
+                expect(capability.inEditContext()).toBe(true);
+            });
+
+            describe("save", function () {
+                beforeEach(function () {
+                    capability.edit();
+                    capability.save();
+                });
+                it("commits the transaction", function () {
+                    expect(mockTransactionService.commit).toHaveBeenCalled();
+                });
+                it("begins a new transaction", function () {
+                    expect(mockTransactionService.startTransaction).toHaveBeenCalled();
+                });
+            });
+
+            describe("finish", function () {
+                beforeEach(function () {
+                    mockTransactionService.isActive.and.returnValue(true);
+                    capability.edit();
+                    capability.finish();
+                });
+                it("cancels the transaction", function () {
+                    expect(mockTransactionService.cancel).toHaveBeenCalled();
+                });
+                it("resets the edit state", function () {
+                    expect(mockStatusCapability.set).toHaveBeenCalledWith('editing', false);
+                });
+            });
+
+            describe("finish", function () {
+                beforeEach(function () {
+                    mockTransactionService.isActive.and.returnValue(false);
+                    capability.edit();
+                });
+
+                it("does not cancel transaction when transaction is not active", function () {
+                    capability.finish();
+                    expect(mockTransactionService.cancel).not.toHaveBeenCalled();
+                });
+
+                it("returns a promise", function () {
+                    expect(capability.finish() instanceof Promise).toBe(true);
+                });
+
+            });
+
+            describe("dirty", function () {
+                var model = {};
+
+                beforeEach(function () {
+                    mockDomainObject.getModel.and.returnValue(model);
+                    capability.edit();
+                    capability.finish();
+                });
+                it("returns true if the object has been modified since it"
+                    + " was last persisted", function () {
+                    mockTransactionService.size.and.returnValue(0);
+                    expect(capability.dirty()).toBe(false);
+                    mockTransactionService.size.and.returnValue(1);
+                    expect(capability.dirty()).toBe(true);
+                });
+            });
+        });
+    }
+);

platform/commonUI/edit/test/capabilities/TransactionCapabilityDecoratorSpec.js

@@ -20,52 +20,35 @@
  * at runtime from the About dialog for additional information.
  *****************************************************************************/
 
-export default class Transaction {
-    constructor(objectAPI) {
-        this.dirtyObjects = new Set();
-        this.objectAPI = objectAPI;
-    }
+define(
+    [
+        "../../src/capabilities/TransactionalPersistenceCapability",
+        "../../src/capabilities/TransactionCapabilityDecorator"
+    ],
+    function (TransactionalPersistenceCapability, TransactionCapabilityDecorator) {
 
-    add(object) {
-        this.dirtyObjects.add(object);
-    }
+        describe("The transaction capability decorator", function () {
+            var mockQ,
+                mockTransactionService,
+                mockCapabilityService,
+                provider;
 
-    cancel() {
-        return this._clear();
-    }
-
-    commit() {
-        const promiseArray = [];
-        const save = this.objectAPI.save.bind(this.objectAPI);
-        this.dirtyObjects.forEach(object => {
-            promiseArray.push(this.createDirtyObjectPromise(object, save));
-        });
-
-        return Promise.all(promiseArray);
-    }
-
-    createDirtyObjectPromise(object, action) {
-        return new Promise((resolve, reject) => {
-            action(object)
-                .then(resolve)
-                .catch(reject)
-                .finally(() => {
-                    this.dirtyObjects.delete(object);
+            beforeEach(function () {
+                mockQ = {};
+                mockTransactionService = {};
+                mockCapabilityService = jasmine.createSpyObj("capabilityService", ["getCapabilities"]);
+                mockCapabilityService.getCapabilities.and.returnValue({
+                    persistence: function () {}
                 });
+
+                provider = new TransactionCapabilityDecorator(mockQ, mockTransactionService, mockCapabilityService);
+
+            });
+            it("decorates the persistence capability", function () {
+                var capabilities = provider.getCapabilities();
+                expect(capabilities.persistence({}) instanceof TransactionalPersistenceCapability).toBe(true);
+            });
+
         });
     }
-
-    start() {
-        this.dirtyObjects = new Set();
-    }
-
-    _clear() {
-        const promiseArray = [];
-        const refresh = this.objectAPI.refresh.bind(this.objectAPI);
-        this.dirtyObjects.forEach(object => {
-            promiseArray.push(this.createDirtyObjectPromise(object, refresh));
-        });
-
-        return Promise.all(promiseArray);
-    }
-}
+);

platform/commonUI/edit/test/capabilities/TransactionalPersistenceCapabilitySpec.js

@@ -0,0 +1,111 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, 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/capabilities/TransactionalPersistenceCapability"
+    ],
+    function (TransactionalPersistenceCapability) {
+
+        function fastPromise(val) {
+            return {
+                then: function (callback) {
+                    return callback(val);
+                }
+            };
+        }
+
+        describe("The transactional persistence decorator", function () {
+            var mockQ,
+                mockTransactionManager,
+                mockPersistence,
+                mockDomainObject,
+                testId,
+                capability;
+
+            beforeEach(function () {
+                testId = "test-id";
+
+                mockQ = jasmine.createSpyObj("$q", ["when"]);
+                mockQ.when.and.callFake(function (val) {
+                    return fastPromise(val);
+                });
+                mockTransactionManager = jasmine.createSpyObj(
+                    "transactionService",
+                    ["isActive", "addToTransaction", "clearTransactionsFor"]
+                );
+                mockPersistence = jasmine.createSpyObj(
+                    "persistenceCapability",
+                    ["persist", "refresh", "getSpace"]
+                );
+                mockPersistence.persist.and.returnValue(fastPromise());
+                mockPersistence.refresh.and.returnValue(fastPromise());
+
+                mockDomainObject = jasmine.createSpyObj(
+                    "domainObject",
+                    ["getModel", "getId"]
+                );
+                mockDomainObject.getModel.and.returnValue({persisted: 1});
+                mockDomainObject.getId.and.returnValue(testId);
+
+                capability = new TransactionalPersistenceCapability(
+                    mockQ,
+                    mockTransactionManager,
+                    mockPersistence,
+                    mockDomainObject
+                );
+            });
+
+            it("if no transaction is active, passes through to persistence"
+                + " provider", function () {
+                mockTransactionManager.isActive.and.returnValue(false);
+                capability.persist();
+                expect(mockPersistence.persist).toHaveBeenCalled();
+            });
+
+            it("if transaction is active, persist and cancel calls are"
+                + " queued", function () {
+                mockTransactionManager.isActive.and.returnValue(true);
+                capability.persist();
+                expect(mockTransactionManager.addToTransaction).toHaveBeenCalled();
+                mockTransactionManager.addToTransaction.calls.mostRecent().args[1]();
+                expect(mockPersistence.persist).toHaveBeenCalled();
+                mockTransactionManager.addToTransaction.calls.mostRecent().args[2]();
+                expect(mockPersistence.refresh).toHaveBeenCalled();
+            });
+
+            it("wraps getSpace", function () {
+                mockPersistence.getSpace.and.returnValue('foo');
+                expect(capability.getSpace()).toEqual('foo');
+            });
+
+            it("clears transactions and delegates refresh calls", function () {
+                capability.refresh();
+                expect(mockTransactionManager.clearTransactionsFor)
+                    .toHaveBeenCalledWith(testId);
+                expect(mockPersistence.refresh)
+                    .toHaveBeenCalled();
+            });
+
+        });
+    }
+);

platform/commonUI/edit/test/services/NestedTransactionSpec.js

@@ -0,0 +1,75 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, 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/NestedTransaction"], function (NestedTransaction) {
+    var TRANSACTION_METHODS = ['add', 'commit', 'cancel', 'size'];
+
+    describe("A NestedTransaction", function () {
+        var mockTransaction,
+            nestedTransaction;
+
+        beforeEach(function () {
+            mockTransaction =
+                jasmine.createSpyObj('transaction', TRANSACTION_METHODS);
+            nestedTransaction = new NestedTransaction(mockTransaction);
+        });
+
+        it("exposes a Transaction's interface", function () {
+            TRANSACTION_METHODS.forEach(function (method) {
+                expect(nestedTransaction[method])
+                    .toEqual(jasmine.any(Function));
+            });
+        });
+
+        describe("when callbacks are added", function () {
+            var mockCommit,
+                mockCancel;
+
+            beforeEach(function () {
+                mockCommit = jasmine.createSpy('commit');
+                mockCancel = jasmine.createSpy('cancel');
+                nestedTransaction.add(mockCommit, mockCancel);
+            });
+
+            it("does not interact with its parent transaction", function () {
+                TRANSACTION_METHODS.forEach(function (method) {
+                    expect(mockTransaction[method])
+                        .not.toHaveBeenCalled();
+                });
+            });
+
+            describe("and the transaction is committed", function () {
+                beforeEach(function () {
+                    nestedTransaction.commit();
+                });
+
+                it("adds to its parent transaction", function () {
+                    expect(mockTransaction.add).toHaveBeenCalledWith(
+                        jasmine.any(Function),
+                        jasmine.any(Function)
+                    );
+                });
+            });
+        });
+    });
+});
+

platform/commonUI/edit/test/services/TransactionManagerSpec.js

@@ -0,0 +1,141 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, 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/TransactionManager"],
+    function (TransactionManager) {
+        describe("TransactionManager", function () {
+            var mockTransactionService,
+                testId,
+                mockOnCommit,
+                mockOnCancel,
+                mockRemoves,
+                mockPromise,
+                manager;
+
+            beforeEach(function () {
+                mockRemoves = [];
+                mockTransactionService = jasmine.createSpyObj(
+                    "transactionService",
+                    ["addToTransaction", "isActive"]
+                );
+                mockOnCommit = jasmine.createSpy('commit');
+                mockOnCancel = jasmine.createSpy('cancel');
+                testId = 'test-id';
+                mockPromise = jasmine.createSpyObj('promise', ['then']);
+
+                mockOnCommit.and.returnValue(mockPromise);
+                mockOnCancel.and.returnValue(mockPromise);
+
+                mockTransactionService.addToTransaction.and.callFake(function () {
+                    var mockRemove =
+                        jasmine.createSpy('remove-' + mockRemoves.length);
+                    mockRemoves.push(mockRemove);
+
+                    return mockRemove;
+                });
+
+                manager = new TransactionManager(mockTransactionService);
+            });
+
+            it("delegates isActive calls", function () {
+                [false, true].forEach(function (state) {
+                    mockTransactionService.isActive.and.returnValue(state);
+                    expect(manager.isActive()).toBe(state);
+                });
+            });
+
+            describe("when addToTransaction is called", function () {
+                beforeEach(function () {
+                    manager.addToTransaction(
+                        testId,
+                        mockOnCommit,
+                        mockOnCancel
+                    );
+                });
+
+                it("adds callbacks to the active transaction", function () {
+                    expect(mockTransactionService.addToTransaction)
+                        .toHaveBeenCalledWith(
+                            jasmine.any(Function),
+                            jasmine.any(Function)
+                        );
+                });
+
+                it("invokes passed-in callbacks from its own callbacks", function () {
+                    expect(mockOnCommit).not.toHaveBeenCalled();
+                    mockTransactionService.addToTransaction
+                        .calls.mostRecent().args[0]();
+                    expect(mockOnCommit).toHaveBeenCalled();
+
+                    expect(mockOnCancel).not.toHaveBeenCalled();
+                    mockTransactionService.addToTransaction
+                        .calls.mostRecent().args[1]();
+                    expect(mockOnCancel).toHaveBeenCalled();
+                });
+
+                describe("Adds callbacks to transaction", function () {
+                    beforeEach(function () {
+                        spyOn(manager, 'clearTransactionsFor');
+                        manager.clearTransactionsFor.and.callThrough();
+                    });
+
+                    it("and clears pending calls if same object", function () {
+                        manager.addToTransaction(
+                            testId,
+                            jasmine.createSpy(),
+                            jasmine.createSpy()
+                        );
+                        expect(manager.clearTransactionsFor).toHaveBeenCalledWith(testId);
+                    });
+
+                    it("and does not clear pending calls if different object", function () {
+                        manager.addToTransaction(
+                            'other-id',
+                            jasmine.createSpy(),
+                            jasmine.createSpy()
+                        );
+                        expect(manager.clearTransactionsFor).not.toHaveBeenCalled();
+                    });
+
+                    afterEach(function () {
+                        expect(mockTransactionService.addToTransaction.calls.count()).toEqual(2);
+                    });
+                });
+
+                it("does not remove callbacks from the transaction", function () {
+                    expect(mockRemoves[0]).not.toHaveBeenCalled();
+                });
+
+                describe("and clearTransactionsFor is subsequently called", function () {
+                    beforeEach(function () {
+                        manager.clearTransactionsFor(testId);
+                    });
+
+                    it("removes callbacks from the transaction", function () {
+                        expect(mockRemoves[0]).toHaveBeenCalled();
+                    });
+                });
+            });
+        });
+    }
+);

platform/commonUI/edit/test/services/TransactionServiceSpec.js

@@ -0,0 +1,139 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, 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/TransactionService"],
+    function (TransactionService) {
+
+        describe("The Transaction Service", function () {
+            var mockQ,
+                mockLog,
+                mockCacheService,
+                transactionService;
+
+            function fastPromise(val) {
+                return {
+                    then: function (callback) {
+                        return fastPromise(callback(val));
+                    }
+                };
+            }
+
+            beforeEach(function () {
+                mockQ = jasmine.createSpyObj("$q", ["all"]);
+                mockCacheService = jasmine.createSpyObj("cacheService", ["flush"]);
+                mockQ.all.and.returnValue(fastPromise());
+                mockLog = jasmine.createSpyObj("$log", ["error"]);
+                transactionService = new TransactionService(mockQ, mockLog, mockCacheService);
+            });
+
+            it("isActive returns true if a transaction is in progress", function () {
+                expect(transactionService.isActive()).toBe(false);
+                transactionService.startTransaction();
+                expect(transactionService.isActive()).toBe(true);
+            });
+
+            it("addToTransaction queues onCommit and onCancel functions", function () {
+                var onCommit = jasmine.createSpy('onCommit'),
+                    onCancel = jasmine.createSpy('onCancel');
+
+                transactionService.startTransaction();
+                transactionService.addToTransaction(onCommit, onCancel);
+                expect(transactionService.size()).toBe(1);
+            });
+
+            it("size function returns size of commit and cancel queues", function () {
+                var onCommit = jasmine.createSpy('onCommit'),
+                    onCancel = jasmine.createSpy('onCancel');
+
+                transactionService.startTransaction();
+                transactionService.addToTransaction(onCommit, onCancel);
+                transactionService.addToTransaction(onCommit, onCancel);
+                transactionService.addToTransaction(onCommit, onCancel);
+                expect(transactionService.size()).toBe(3);
+            });
+
+            describe("commit", function () {
+                var onCommits;
+
+                beforeEach(function () {
+                    onCommits = [0, 1, 2].map(function (val) {
+                        return jasmine.createSpy("onCommit" + val);
+                    });
+
+                    transactionService.startTransaction();
+                    onCommits.forEach(transactionService.addToTransaction.bind(transactionService));
+                });
+
+                it("commit calls all queued commit functions", function () {
+                    expect(transactionService.size()).toBe(3);
+
+                    return transactionService.commit().then(() => {
+                        onCommits.forEach(function (spy) {
+                            expect(spy).toHaveBeenCalled();
+                        });
+                    });
+                });
+
+                it("commit resets active state and clears queues", function () {
+                    return transactionService.commit().then(() => {
+                        expect(transactionService.isActive()).toBe(false);
+                        expect(transactionService.size()).toBe(0);
+                        expect(transactionService.size()).toBe(0);
+                    });
+                });
+
+            });
+
+            describe("cancel", function () {
+                var onCancels;
+
+                beforeEach(function () {
+                    onCancels = [0, 1, 2].map(function (val) {
+                        return jasmine.createSpy("onCancel" + val);
+                    });
+
+                    transactionService.startTransaction();
+                    onCancels.forEach(function (onCancel) {
+                        transactionService.addToTransaction(undefined, onCancel);
+                    });
+                });
+
+                it("cancel calls all queued cancel functions", function () {
+                    expect(transactionService.size()).toBe(3);
+                    transactionService.cancel();
+                    onCancels.forEach(function (spy) {
+                        expect(spy).toHaveBeenCalled();
+                    });
+                });
+
+                it("cancel resets active state and clears queues", function () {
+                    transactionService.cancel();
+                    expect(transactionService.isActive()).toBe(false);
+                    expect(transactionService.size()).toBe(0);
+                });
+
+            });
+
+        });
+    }
+);

platform/commonUI/edit/test/services/TransactionSpec.js

@@ -0,0 +1,109 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, 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/Transaction"],
+    function (Transaction) {
+
+        describe("A Transaction", function () {
+            var mockLog,
+                transaction;
+
+            beforeEach(function () {
+                mockLog = jasmine.createSpyObj(
+                    '$log',
+                    ['warn', 'info', 'error', 'debug']
+                );
+                transaction = new Transaction(mockLog);
+            });
+
+            it("initially has a size of zero", function () {
+                expect(transaction.size()).toEqual(0);
+            });
+
+            describe("when callbacks are added", function () {
+                var mockCommit,
+                    mockCancel,
+                    remove;
+
+                beforeEach(function () {
+                    mockCommit = jasmine.createSpy('commit');
+                    mockCancel = jasmine.createSpy('cancel');
+                    remove = transaction.add(mockCommit, mockCancel);
+                });
+
+                it("reports a new size", function () {
+                    expect(transaction.size()).toEqual(1);
+                });
+
+                it("returns a function to remove those callbacks", function () {
+                    expect(remove).toEqual(jasmine.any(Function));
+                    remove();
+                    expect(transaction.size()).toEqual(0);
+                });
+
+                describe("and the transaction is committed", function () {
+                    beforeEach(function () {
+                        transaction.commit();
+                    });
+
+                    it("triggers the commit callback", function () {
+                        expect(mockCommit).toHaveBeenCalled();
+                    });
+
+                    it("does not trigger the cancel callback", function () {
+                        expect(mockCancel).not.toHaveBeenCalled();
+                    });
+                });
+
+                describe("and the transaction is cancelled", function () {
+                    beforeEach(function () {
+                        transaction.cancel();
+                    });
+
+                    it("triggers the cancel callback", function () {
+                        expect(mockCancel).toHaveBeenCalled();
+                    });
+
+                    it("does not trigger the commit callback", function () {
+                        expect(mockCommit).not.toHaveBeenCalled();
+                    });
+                });
+
+                describe("and an exception is encountered during commit", function () {
+                    beforeEach(function () {
+                        mockCommit.and.callFake(function () {
+                            throw new Error("test error");
+                        });
+                        transaction.commit();
+                    });
+
+                    it("logs an error", function () {
+                        expect(mockLog.error).toHaveBeenCalled();
+                    });
+                });
+            });
+
+        });
+    }
+);
+

platform/commonUI/formats/src/UTCTimeFormat.js

@@ -25,14 +25,15 @@ define([
 ], function (
     moment
 ) {
-    const DATE_FORMAT = "YYYY-MM-DD HH:mm:ss.SSS";
-    const DATE_FORMATS = [
-        DATE_FORMAT,
-        DATE_FORMAT + "Z",
-        "YYYY-MM-DD HH:mm:ss",
-        "YYYY-MM-DD HH:mm",
-        "YYYY-MM-DD"
-    ];
+
+    var DATE_FORMAT = "YYYY-MM-DD HH:mm:ss.SSS",
+        DATE_FORMATS = [
+            DATE_FORMAT,
+            DATE_FORMAT + "Z",
+            "YYYY-MM-DD HH:mm:ss",
+            "YYYY-MM-DD HH:mm",
+            "YYYY-MM-DD"
+        ];
 
     /**
      * @typedef Scale
@@ -52,27 +53,15 @@ define([
         this.key = "utc";
     }
 
-    /**
-     * @param {string} formatString
-     * @returns the value of formatString if the value is a string type and exists in the DATE_FORMATS array; otherwise the DATE_FORMAT value.
-     */
-    function validateFormatString(formatString) {
-        return typeof formatString === 'string' && DATE_FORMATS.includes(formatString) ? formatString : DATE_FORMAT;
-    }
-
     /**
      * @param {number} value The value to format.
-     * @param {string} formatString The string format to format. Default "YYYY-MM-DD HH:mm:ss.SSS" + "Z"
-     * @returns {string} the formatted date(s) according to the proper parameter of formatString or the default value of "YYYY-MM-DD HH:mm:ss.SSS" + "Z".
-     * If multiple values were requested, then an array of
+     * @returns {string} the formatted date(s). If multiple values were requested, then an array of
      * formatted values will be returned. Where a value could not be formatted, `undefined` will be returned at its position
      * in the array.
      */
-    UTCTimeFormat.prototype.format = function (value, formatString) {
+    UTCTimeFormat.prototype.format = function (value) {
         if (value !== undefined) {
-            const format = validateFormatString(formatString);
-
-            return moment.utc(value).format(format) + (formatString ? '' : 'Z');
+            return moment.utc(value).format(DATE_FORMAT) + "Z";
         } else {
             return value;
         }

platform/core/bundle.js

@@ -45,6 +45,7 @@ define([
     "./src/capabilities/MutationCapability",
     "./src/capabilities/DelegationCapability",
     "./src/capabilities/InstantiationCapability",
+    "./src/runs/TransactingMutationListener",
     "./src/services/Now",
     "./src/services/Throttle",
     "./src/services/Topic",
@@ -74,6 +75,7 @@ define([
     MutationCapability,
     DelegationCapability,
     InstantiationCapability,
+    TransactingMutationListener,
     Now,
     Throttle,
     Topic,
@@ -361,6 +363,12 @@ define([
                         ]
                     }
                 ],
+                "runs": [
+                    {
+                        "implementation": TransactingMutationListener,
+                        "depends": ["topic", "transactionService", "cacheService"]
+                    }
+                ],
                 "constants": [
                     {
                         "key": "PERSISTENCE_SPACE",

platform/core/src/runs/TransactingMutationListener.js

@@ -0,0 +1,55 @@
+/*****************************************************************************
+ * 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([], function () {
+
+    /**
+     * Listens for mutation on domain objects and triggers persistence when
+     * it occurs.
+     * @param {Topic} topic the `topic` service; used to listen for mutation
+     * @memberof platform/core
+     */
+    function TransactingMutationListener(
+        topic,
+        transactionService,
+        cacheService
+    ) {
+
+        function hasChanged(domainObject) {
+            var model = domainObject.getModel();
+
+            return model.persisted === undefined || model.modified > model.persisted;
+        }
+
+        var mutationTopic = topic('mutation');
+        mutationTopic.listen(function (domainObject) {
+            var persistence = domainObject.getCapability('persistence');
+            cacheService.put(domainObject.getId(), domainObject.getModel());
+
+            if (hasChanged(domainObject)) {
+                persistence.persist();
+            }
+        });
+    }
+
+    return TransactingMutationListener;
+});

platform/core/test/runs/TransactingMutationListenerSpec.js

@@ -0,0 +1,112 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2021, 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/runs/TransactingMutationListener"],
+    function (TransactingMutationListener) {
+
+        describe("TransactingMutationListener", function () {
+            var mockTopic,
+                mockMutationTopic,
+                mockCacheService,
+                mockTransactionService,
+                mockDomainObject,
+                mockModel,
+                mockPersistence;
+
+            beforeEach(function () {
+                mockTopic = jasmine.createSpy('topic');
+                mockMutationTopic =
+                    jasmine.createSpyObj('mutation', ['listen']);
+                mockCacheService =
+                    jasmine.createSpyObj('cacheService', [
+                        'put'
+                    ]);
+                mockTransactionService =
+                    jasmine.createSpyObj('transactionService', [
+                        'isActive',
+                        'startTransaction',
+                        'commit'
+                    ]);
+                mockDomainObject = jasmine.createSpyObj(
+                    'domainObject',
+                    ['getId', 'getCapability', 'getModel']
+                );
+                mockPersistence = jasmine.createSpyObj(
+                    'persistence',
+                    ['persist', 'refresh', 'persisted']
+                );
+
+                mockTopic.and.callFake(function (t) {
+                    expect(t).toBe('mutation');
+
+                    return mockMutationTopic;
+                });
+
+                mockDomainObject.getId.and.returnValue('mockId');
+                mockDomainObject.getCapability.and.callFake(function (c) {
+                    expect(c).toBe('persistence');
+
+                    return mockPersistence;
+                });
+                mockModel = {};
+                mockDomainObject.getModel.and.returnValue(mockModel);
+
+                mockPersistence.persisted.and.returnValue(true);
+
+                return new TransactingMutationListener(
+                    mockTopic,
+                    mockTransactionService,
+                    mockCacheService
+                );
+            });
+
+            it("listens for mutation", function () {
+                expect(mockMutationTopic.listen)
+                    .toHaveBeenCalledWith(jasmine.any(Function));
+            });
+
+            it("calls persist if the model has changed", function () {
+                mockModel.persisted = Date.now();
+
+                //Mark the model dirty by setting the mutated date later than the last persisted date.
+                mockModel.modified = mockModel.persisted + 1;
+
+                mockMutationTopic.listen.calls.mostRecent()
+                    .args[0](mockDomainObject);
+
+                expect(mockPersistence.persist).toHaveBeenCalled();
+            });
+
+            it("does not call persist if the model has not changed", function () {
+                mockModel.persisted = Date.now();
+
+                mockModel.modified = mockModel.persisted;
+
+                mockMutationTopic.listen.calls.mostRecent()
+                    .args[0](mockDomainObject);
+
+                expect(mockPersistence.persist).not.toHaveBeenCalled();
+            });
+        });
+    }
+);

src/MCT.js

@@ -253,8 +253,6 @@ define([
 
         this.status = new api.StatusAPI(this);
 
-        this.priority = api.PriorityAPI;
-
         this.router = new ApplicationRouter(this);
 
         this.branding = BrandingAPI.default;
@@ -265,7 +263,6 @@ define([
         // Plugins that are installed by default
 
         this.install(this.plugins.Plot());
-        this.install(this.plugins.Chart());
         this.install(this.plugins.TelemetryTable.default());
         this.install(PreviewPlugin.default());
         this.install(LegacyIndicatorsPlugin());

src/adapter/actions/LegacyActionAdapter.js

@@ -28,6 +28,8 @@ export default function LegacyActionAdapter(openmct, legacyActions) {
             return true;
         }
 
+        console.warn(`DEPRECATION WARNING: Action ${action.definition.key} in bundle ${action.bundle.path} is non-contextual and should be migrated.`);
+
         return false;
     }
 

src/adapter/bundle.js

@@ -29,6 +29,7 @@ define([
     './capabilities/APICapabilityDecorator',
     './policies/AdaptedViewPolicy',
     './runs/AlternateCompositionInitializer',
+    './runs/TypeDeprecationChecker',
     './runs/LegacyTelemetryProvider',
     './runs/RegisterLegacyTypes',
     './services/LegacyObjectAPIInterceptor',
@@ -45,6 +46,7 @@ define([
     APICapabilityDecorator,
     AdaptedViewPolicy,
     AlternateCompositionInitializer,
+    TypeDeprecationChecker,
     LegacyTelemetryProvider,
     RegisterLegacyTypes,
     LegacyObjectAPIInterceptor,
@@ -133,6 +135,10 @@ define([
                     }
                 ],
                 runs: [
+                    {
+                        implementation: TypeDeprecationChecker,
+                        depends: ["types[]"]
+                    },
                     {
                         implementation: AlternateCompositionInitializer,
                         depends: ["openmct"]

src/adapter/runs/RegisterLegacyTypes.js

@@ -4,6 +4,12 @@ define([
 
 ) {
     function RegisterLegacyTypes(types, openmct) {
+        types.forEach(function (legacyDefinition) {
+            if (!openmct.types.get(legacyDefinition.key)) {
+                console.warn(`DEPRECATION WARNING: Migrate type ${legacyDefinition.key} from ${legacyDefinition.bundle.path} to use the new Types API.  Legacy type support will be removed soon.`);
+            }
+        });
+
         openmct.types.importLegacyTypes(types);
     }
 

src/adapter/runs/TypeDeprecationChecker.js

@@ -0,0 +1,46 @@
+/*****************************************************************************
+ * Open openmct, Copyright (c) 2014-2021, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open openmct 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 openmct 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 (
+
+) {
+
+    function checkForDeprecatedFunctionality(typeDef) {
+        if (Object.prototype.hasOwnProperty.call(typeDef, 'telemetry')) {
+            console.warn(
+                'DEPRECATION WARNING: Telemetry data on type '
+                + 'registrations will be deprecated in a future version, '
+                + 'please convert to a custom telemetry metadata provider '
+                + 'for type: ' + typeDef.key
+            );
+        }
+    }
+
+    function TypeDeprecationChecker(types) {
+        types.forEach(checkForDeprecatedFunctionality);
+    }
+
+    return TypeDeprecationChecker;
+
+});

src/adapter/views/LegacyViewProvider.js

@@ -15,6 +15,8 @@ define([
     };
 
     function LegacyViewProvider(legacyView, openmct, convertToLegacyObject) {
+        console.warn(`DEPRECATION WARNING: Migrate ${legacyView.key} from ${legacyView.bundle.path} to use the new View APIs.  Legacy view support will be removed soon.`);
+
         return {
             key: legacyView.key,
             name: legacyView.name,

src/adapter/views/TypeInspectorViewProvider.js

@@ -4,6 +4,7 @@ define([
 
 ) {
     function TypeInspectorViewProvider(typeDefinition, openmct, convertToLegacyObject) {
+        console.warn(`DEPRECATION WARNING: Migrate ${typeDefinition.key} from ${typeDefinition.bundle.path} to use the new Inspector View APIs.  Legacy Inspector view support will be removed soon.`);
         let representation = openmct.$injector.get('representations[]')
             .filter((r) => r.key === typeDefinition.inspector)[0];
 

src/api/Editor.js

@@ -34,6 +34,7 @@ export default class Editor extends EventEmitter {
      * Initiate an editing session. This will start a transaction during
      * which any persist operations will be deferred until either save()
      * or finish() are called.
+     * @private
      */
     edit() {
         if (this.editing === true) {
@@ -41,8 +42,8 @@ export default class Editor extends EventEmitter {
         }
 
         this.editing = true;
+        this.getTransactionService().startTransaction();
         this.emit('isEditing', true);
-        this.openmct.objects.startTransaction();
     }
 
     /**
@@ -55,36 +56,41 @@ export default class Editor extends EventEmitter {
     /**
      * Save any unsaved changes from this editing session. This will
      * end the current transaction.
+     *
+     * @private
      */
     save() {
-        const transaction = this.openmct.objects.getActiveTransaction();
+        return this.getTransactionService().commit().then((result) => {
+            this.editing = false;
+            this.emit('isEditing', false);
 
-        return transaction.commit()
-            .then(() => {
-                this.editing = false;
-                this.emit('isEditing', false);
-            }).catch(error => {
-                throw error;
-            }).finally(() => {
-                this.openmct.objects.endTransaction();
-            });
+            return result;
+        }).catch((error) => {
+            throw error;
+        });
     }
 
     /**
      * End the currently active transaction and discard unsaved changes.
+     *
+     * @private
      */
     cancel() {
+        let cancelPromise = this.getTransactionService().cancel();
         this.editing = false;
         this.emit('isEditing', false);
 
-        return new Promise((resolve, reject) => {
-            const transaction = this.openmct.objects.getActiveTransaction();
-            transaction.cancel()
-                .then(resolve)
-                .catch(reject)
-                .finally(() => {
-                    this.openmct.objects.endTransaction();
-                });
-        });
+        return cancelPromise;
+    }
+
+    /**
+     * @private
+     */
+    getTransactionService() {
+        if (!this.transactionService) {
+            this.transactionService = this.openmct.$injector.get('transactionService');
+        }
+
+        return this.transactionService;
     }
 }

src/api/api.js

@@ -31,8 +31,7 @@ define([
     './Editor',
     './menu/MenuAPI',
     './actions/ActionsAPI',
-    './status/StatusAPI',
-    './priority/PriorityAPI'
+    './status/StatusAPI'
 ], function (
     TimeAPI,
     ObjectAPI,
@@ -44,8 +43,7 @@ define([
     EditorAPI,
     MenuAPI,
     ActionsAPI,
-    StatusAPI,
-    PriorityAPI
+    StatusAPI
 ) {
     return {
         TimeAPI: TimeAPI.default,
@@ -58,7 +56,6 @@ define([
         EditorAPI: EditorAPI,
         MenuAPI: MenuAPI.default,
         ActionsAPI: ActionsAPI.default,
-        StatusAPI: StatusAPI.default,
-        PriorityAPI: PriorityAPI.default
+        StatusAPI: StatusAPI.default
     };
 });

src/api/indicators/IndicatorAPI.js

@@ -31,22 +31,14 @@ define([
         this.indicatorObjects = [];
     }
 
-    IndicatorAPI.prototype.getIndicatorObjectsByPriority = function () {
-        const sortedIndicators = this.indicatorObjects.sort((a, b) => b.priority - a.priority);
-
-        return sortedIndicators;
-    };
-
     IndicatorAPI.prototype.simpleIndicator = function () {
         return new SimpleIndicator(this.openmct);
     };
 
     /**
      * Accepts an indicator object, which is a simple object
-     * with a two attributes: 'element' which has an HTMLElement
-     * as its value, and 'priority' with an integer that specifies its order in the layout.
-     * The lower the priority, the further to the right the element is placed.
-     * If undefined, the priority will be assigned -1.
+     * with a single attribute, 'element' which has an HTMLElement
+     * as its value.
      *
      * We provide .simpleIndicator() as a convenience function
      * which will create a default Open MCT indicator that can
@@ -55,7 +47,7 @@ define([
      * and dynamic behavior.
      *
      * Eg.
-     * const myIndicator = openmct.indicators.simpleIndicator();
+     * var myIndicator = openmct.indicators.simpleIndicator();
      * openmct.indicators.add(myIndicator);
      *
      * myIndicator.text("Hello World!");
@@ -63,10 +55,6 @@ define([
      *
      */
     IndicatorAPI.prototype.add = function (indicator) {
-        if (!indicator.priority) {
-            indicator.priority = this.openmct.priority.DEFAULT;
-        }
-
         this.indicatorObjects.push(indicator);
     };
 

src/api/indicators/IndicatorAPISpec.js

@@ -19,64 +19,97 @@
  * this source code distribution or the Licensing information page available
  * at runtime from the About dialog for additional information.
  *****************************************************************************/
-import { createOpenMct, resetApplicationState } from '../../utils/testing';
-import SimpleIndicator from './SimpleIndicator';
 
-describe("The Indicator API", () => {
-    let openmct;
+define(
+    [
+        "../../MCT",
+        "../../../platform/commonUI/general/src/directives/MCTIndicators"
+    ],
+    function (
+        MCT,
+        MCTIndicators
+    ) {
+        xdescribe("The Indicator API", function () {
+            let openmct;
+            let directive;
+            let holderElement;
 
-    beforeEach(() => {
-        openmct = createOpenMct();
+            beforeEach(function () {
+                openmct = new MCT();
+                directive = new MCTIndicators(openmct);
+                holderElement = document.createElement('div');
+            });
+
+            describe("The simple indicator", function () {
+                let simpleIndicator;
+
+                beforeEach(function () {
+                    simpleIndicator = openmct.indicators.simpleIndicator();
+                    openmct.indicators.add(simpleIndicator);
+                    renderIndicators();
+                });
+
+                it("applies the set icon class", function () {
+                    simpleIndicator.iconClass('testIconClass');
+
+                    expect(getIconElement().classList.contains('testIconClass')).toBe(true);
+
+                    simpleIndicator.iconClass('anotherIconClass');
+                    expect(getIconElement().classList.contains('testIconClass')).toBe(false);
+                    expect(getIconElement().classList.contains('anotherIconClass')).toBe(true);
+                });
+
+                it("applies the set status class", function () {
+                    simpleIndicator.statusClass('testStatusClass');
+
+                    expect(getIconElement().classList.contains('testStatusClass')).toBe(true);
+                    simpleIndicator.statusClass('anotherStatusClass');
+                    expect(getIconElement().classList.contains('testStatusClass')).toBe(false);
+                    expect(getIconElement().classList.contains('anotherStatusClass')).toBe(true);
+                });
+
+                it("displays the set text", function () {
+                    simpleIndicator.text('some test text');
+                    expect(getTextElement().textContent.trim()).toEqual('some test text');
+                });
+
+                it("sets the indicator's title", function () {
+                    simpleIndicator.description('a test description');
+                    expect(getIndicatorElement().getAttribute('title')).toEqual('a test description');
+                });
+
+                it("Hides indicator icon if no text is set", function () {
+                    simpleIndicator.text('');
+                    expect(getIndicatorElement().classList.contains('hidden')).toBe(true);
+                });
+
+                function getIconElement() {
+                    return holderElement.querySelector('.ls-indicator');
+                }
+
+                function getIndicatorElement() {
+                    return holderElement.querySelector('.ls-indicator');
+                }
+
+                function getTextElement() {
+                    return holderElement.querySelector('.indicator-text');
+                }
+            });
+
+            it("Supports registration of a completely custom indicator", function () {
+                const customIndicator = document.createElement('div');
+                customIndicator.classList.add('customIndicator');
+                customIndicator.textContent = 'A custom indicator';
+
+                openmct.indicators.add({element: customIndicator});
+                renderIndicators();
+
+                expect(holderElement.querySelector('.customIndicator').textContent.trim()).toEqual('A custom indicator');
+            });
+
+            function renderIndicators() {
+                directive.link({}, holderElement);
+            }
+
+        });
     });
-
-    afterEach(() => {
-        return resetApplicationState(openmct);
-    });
-
-    function generateIndicator(className, label, priority) {
-        const element = document.createElement('div');
-        element.classList.add(className);
-        const textNode = document.createTextNode(label);
-        element.appendChild(textNode);
-        const testIndicator = {
-            element,
-            priority
-        };
-
-        return testIndicator;
-    }
-
-    it("can register an indicator", () => {
-        const testIndicator = generateIndicator('test-indicator', 'This is a test indicator', 2);
-        openmct.indicators.add(testIndicator);
-        expect(openmct.indicators.indicatorObjects).toBeDefined();
-        // notifier indicator is installed by default
-        expect(openmct.indicators.indicatorObjects.length).toBe(2);
-    });
-
-    it("can order indicators based on priority", () => {
-        const testIndicator1 = generateIndicator('test-indicator-1', 'This is a test indicator', openmct.priority.LOW);
-        openmct.indicators.add(testIndicator1);
-
-        const testIndicator2 = generateIndicator('test-indicator-2', 'This is another test indicator', openmct.priority.DEFAULT);
-        openmct.indicators.add(testIndicator2);
-
-        const testIndicator3 = generateIndicator('test-indicator-3', 'This is yet another test indicator', openmct.priority.LOW);
-        openmct.indicators.add(testIndicator3);
-
-        const testIndicator4 = generateIndicator('test-indicator-4', 'This is yet another test indicator', openmct.priority.HIGH);
-        openmct.indicators.add(testIndicator4);
-
-        expect(openmct.indicators.indicatorObjects.length).toBe(5);
-        const indicatorObjectsByPriority = openmct.indicators.getIndicatorObjectsByPriority();
-        expect(indicatorObjectsByPriority.length).toBe(5);
-        expect(indicatorObjectsByPriority[2].priority).toBe(openmct.priority.DEFAULT);
-    });
-
-    it("the simple indicator can be added", () => {
-        const simpleIndicator = new SimpleIndicator(openmct);
-        openmct.indicators.add(simpleIndicator);
-
-        expect(openmct.indicators.indicatorObjects.length).toBe(2);
-    });
-});

src/api/indicators/SimpleIndicator.js

@@ -27,7 +27,6 @@ define(['zepto', './res/indicator-template.html'],
         function SimpleIndicator(openmct) {
             this.openmct = openmct;
             this.element = $(indicatorTemplate)[0];
-            this.priority = openmct.priority.DEFAULT;
 
             this.textElement = this.element.querySelector('.js-indicator-text');
 

src/api/objects/MutableDomainObject.js

@@ -129,7 +129,9 @@ class MutableDomainObject {
 
         mutable.$observe('$_synchronize_model', (updatedObject) => {
             let clone = JSON.parse(JSON.stringify(updatedObject));
-            utils.refresh(mutable, clone);
+            let deleted = _.difference(Object.keys(mutable), Object.keys(updatedObject));
+            deleted.forEach((propertyName) => delete mutable[propertyName]);
+            Object.assign(mutable, clone);
         });
 
         return mutable;

src/api/objects/ObjectAPI.js

@@ -26,7 +26,6 @@ import RootRegistry from './RootRegistry';
 import RootObjectProvider from './RootObjectProvider';
 import EventEmitter from 'EventEmitter';
 import InterceptorRegistry from './InterceptorRegistry';
-import Transaction from './Transaction';
 import ConflictError from './ConflictError';
 
 /**
@@ -42,7 +41,7 @@ function ObjectAPI(typeRegistry, openmct) {
     this.providers = {};
     this.rootRegistry = new RootRegistry();
     this.injectIdentifierService = function () {
-        this.identifierService = this.openmct.$injector.get("identifierService");
+        this.identifierService = openmct.$injector.get("identifierService");
     };
 
     this.rootProvider = new RootObjectProvider(this.rootRegistry);
@@ -93,14 +92,6 @@ ObjectAPI.prototype.getProvider = function (identifier) {
     return this.providers[namespace] || this.fallbackProvider;
 };
 
-/**
- * Get an active transaction instance
- * @returns {Transaction} a transaction object
- */
-ObjectAPI.prototype.getActiveTransaction = function () {
-    return this.transaction;
-};
-
 /**
  * Get the root-level object.
  * @returns {Promise.<DomainObject>} a promise for the root object
@@ -198,12 +189,6 @@ ObjectAPI.prototype.get = function (identifier, abortSignal) {
         delete this.cache[keystring];
 
         result = this.applyGetInterceptors(identifier, result);
-        if (result.isMutable) {
-            result.$refresh(result);
-        } else {
-            let mutableDomainObject = this._toMutable(result);
-            mutableDomainObject.$refresh(result);
-        }
 
         return result;
     }).catch((result) => {
@@ -330,17 +315,13 @@ ObjectAPI.prototype.save = function (domainObject) {
                 savedReject = reject;
             });
             domainObject.persisted = persistedTime;
-            const newObjectPromise = provider.create(domainObject);
-            if (newObjectPromise) {
-                newObjectPromise.then(response => {
+            provider.create(domainObject)
+                .then((response) => {
                     this.mutate(domainObject, 'persisted', persistedTime);
                     savedResolve(response);
                 }).catch((error) => {
                     savedReject(error);
                 });
-            } else {
-                result = Promise.reject(`[ObjectAPI][save] Object provider returned ${newObjectPromise} when creating new object.`);
-            }
         } else {
             domainObject.persisted = persistedTime;
             this.mutate(domainObject, 'persisted', persistedTime);
@@ -351,24 +332,6 @@ ObjectAPI.prototype.save = function (domainObject) {
     return result;
 };
 
-/**
- * After entering into edit mode, creates a new instance of Transaction to keep track of changes in Objects
- */
-ObjectAPI.prototype.startTransaction = function () {
-    if (this.isTransactionActive()) {
-        throw new Error("Unable to start new Transaction: Previous Transaction is active");
-    }
-
-    this.transaction = new Transaction(this);
-};
-
-/**
- * Clear instance of Transaction
- */
-ObjectAPI.prototype.endTransaction = function () {
-    this.transaction = null;
-};
-
 /**
  * Add a root-level object.
  * @param {module:openmct.ObjectAPI~Identifier|function} an array of
@@ -458,12 +421,6 @@ ObjectAPI.prototype.mutate = function (domainObject, path, value) {
         //Destroy temporary mutable object
         this.destroyMutable(mutableDomainObject);
     }
-
-    if (this.isTransactionActive()) {
-        this.transaction.add(domainObject);
-    } else {
-        this.save(domainObject);
-    }
 };
 
 /**
@@ -500,23 +457,6 @@ ObjectAPI.prototype._toMutable = function (object) {
     return mutableObject;
 };
 
-/**
- * Updates a domain object based on its latest persisted state. Note that this will mutate the provided object.
- * @param {module:openmct.DomainObject} domainObject an object to refresh from its persistence store
- * @returns {Promise} the provided object, updated to reflect the latest persisted state of the object.
- */
-ObjectAPI.prototype.refresh = async function (domainObject) {
-    const refreshedObject = await this.get(domainObject.identifier);
-
-    if (domainObject.isMutable) {
-        domainObject.$refresh(refreshedObject);
-    } else {
-        utils.refresh(domainObject, refreshedObject);
-    }
-
-    return domainObject;
-};
-
 /**
  * @param module:openmct.ObjectAPI~Identifier identifier An object identifier
  * @returns {boolean} true if the object can be mutated, otherwise returns false
@@ -593,10 +533,6 @@ ObjectAPI.prototype.isObjectPathToALink = function (domainObject, objectPath) {
         && domainObject.location !== this.makeKeyString(objectPath[1].identifier);
 };
 
-ObjectAPI.prototype.isTransactionActive = function () {
-    return Boolean(this.transaction && this.openmct.editor.isEditing());
-};
-
 /**
  * Uniquely identifies a domain object.
  *

src/api/objects/ObjectAPISpec.js

@@ -26,10 +26,6 @@ describe("The Object API", () => {
 
         openmct.$injector.get.and.returnValue(mockIdentifierService);
         objectAPI = new ObjectAPI(typeRegistry, openmct);
-
-        openmct.editor = {};
-        openmct.editor.isEditing = () => false;
-
         mockDomainObject = {
             identifier: {
                 namespace: TEST_NAMESPACE,
@@ -227,28 +223,6 @@ describe("The Object API", () => {
             expect(testObject.name).toBe(MUTATED_NAME);
         });
 
-        it('Provides a way of refreshing an object from the persistence store', () => {
-            const modifiedTestObject = JSON.parse(JSON.stringify(testObject));
-            const OTHER_ATTRIBUTE_VALUE = 'Modified value';
-            const NEW_ATTRIBUTE_VALUE = 'A new attribute';
-            modifiedTestObject.otherAttribute = OTHER_ATTRIBUTE_VALUE;
-            modifiedTestObject.newAttribute = NEW_ATTRIBUTE_VALUE;
-            delete modifiedTestObject.objectAttribute;
-
-            spyOn(objectAPI, 'get');
-            objectAPI.get.and.returnValue(Promise.resolve(modifiedTestObject));
-
-            expect(objectAPI.get).not.toHaveBeenCalled();
-
-            return objectAPI.refresh(testObject).then(() => {
-                expect(objectAPI.get).toHaveBeenCalledWith(testObject.identifier);
-
-                expect(testObject.otherAttribute).toEqual(OTHER_ATTRIBUTE_VALUE);
-                expect(testObject.newAttribute).toEqual(NEW_ATTRIBUTE_VALUE);
-                expect(testObject.objectAttribute).not.toBeDefined();
-            });
-        });
-
         describe ('uses a MutableDomainObject', () => {
             it('and retains properties of original object ', function () {
                 expect(hasOwnProperty(mutable, 'identifier')).toBe(true);

src/api/objects/object-utils.js

@@ -165,19 +165,12 @@ define([
         return identifierEquals(a.identifier, b.identifier);
     }
 
-    function refresh(oldObject, newObject) {
-        let deleted = _.difference(Object.keys(oldObject), Object.keys(newObject));
-        deleted.forEach((propertyName) => delete oldObject[propertyName]);
-        Object.assign(oldObject, newObject);
-    }
-
     return {
         toOldFormat: toOldFormat,
         toNewFormat: toNewFormat,
         makeKeyString: makeKeyString,
         parseKeyString: parseKeyString,
         equals: objectEquals,
-        identifierEquals: identifierEquals,
-        refresh: refresh
+        identifierEquals: identifierEquals
     };
 });

src/api/telemetry/TelemetryAPI.js

@@ -180,6 +180,12 @@ define([
      * @memberof module:openmct.TelemetryAPI~TelemetryProvider#
      */
     TelemetryAPI.prototype.canProvideTelemetry = function (domainObject) {
+        console.warn(
+            'DEPRECATION WARNING: openmct.telemetry.canProvideTelemetry '
+            + 'will not be supported in future versions of Open MCT.  Please '
+            + 'use openmct.telemetry.isTelemetryObject instead.'
+        );
+
         return Boolean(this.findSubscriptionProvider(domainObject))
                || Boolean(this.findRequestProvider(domainObject));
     };

src/api/telemetry/TelemetryCollection.js

@@ -49,6 +49,7 @@ export class TelemetryCollection extends EventEmitter {
         this.parseTime = undefined;
         this.metadata = this.openmct.telemetry.getMetadata(domainObject);
         this.unsubscribe = undefined;
+        this.historicalProvider = undefined;
         this.options = options;
         this.pageState = undefined;
         this.lastBounds = undefined;
@@ -64,13 +65,13 @@ export class TelemetryCollection extends EventEmitter {
             this._error(ERRORS.LOADED);
         }
 
-        this._setTimeSystem(this.openmct.time.timeSystem());
+        this._timeSystem(this.openmct.time.timeSystem());
         this.lastBounds = this.openmct.time.bounds();
 
         this._watchBounds();
         this._watchTimeSystem();
 
-        this._requestHistoricalTelemetry();
+        this._initiateHistoricalRequests();
         this._initiateSubscriptionTelemetry();
 
         this.loaded = true;
@@ -102,25 +103,31 @@ export class TelemetryCollection extends EventEmitter {
         return this.boundedTelemetry;
     }
 
+    /**
+     * Sets up  the telemetry collection for historical requests,
+     * this uses the "standardizeRequestOptions" from Telemetry API
+     * @private
+     */
+    _initiateHistoricalRequests() {
+        this.openmct.telemetry.standardizeRequestOptions(this.options);
+        this.historicalProvider = this.openmct.telemetry.
+            findRequestProvider(this.domainObject, this.options);
+
+        this._requestHistoricalTelemetry();
+    }
+
     /**
      * If a historical provider exists, then historical requests will be made
      * @private
      */
     async _requestHistoricalTelemetry() {
-        let options = { ...this.options };
-        let historicalProvider;
-
-        this.openmct.telemetry.standardizeRequestOptions(options);
-        historicalProvider = this.openmct.telemetry.
-            findRequestProvider(this.domainObject, options);
-
-        if (!historicalProvider) {
+        if (!this.historicalProvider) {
             return;
         }
 
         let historicalData;
 
-        options.onPartialResponse = this._processNewTelemetry.bind(this);
+        this.options.onPartialResponse = this._processNewTelemetry.bind(this);
 
         try {
             if (this.requestAbort) {
@@ -128,9 +135,9 @@ export class TelemetryCollection extends EventEmitter {
             }
 
             this.requestAbort = new AbortController();
-            options.signal = this.requestAbort.signal;
+            this.options.signal = this.requestAbort.signal;
             this.emit('requestStarted');
-            historicalData = await historicalProvider.request(this.domainObject, options);
+            historicalData = await this.historicalProvider.request(this.domainObject, this.options);
         } catch (error) {
             if (error.name !== 'AbortError') {
                 console.error('Error requesting telemetry data...');
@@ -172,10 +179,6 @@ export class TelemetryCollection extends EventEmitter {
      * @private
      */
     _processNewTelemetry(telemetryData) {
-        if (telemetryData === undefined) {
-            return;
-        }
-
         let data = Array.isArray(telemetryData) ? telemetryData : [telemetryData];
         let parsedValue;
         let beforeStartOfBounds;
@@ -202,10 +205,9 @@ export class TelemetryCollection extends EventEmitter {
 
                     if (endIndex > startIndex) {
                         let potentialDupes = this.boundedTelemetry.slice(startIndex, endIndex);
+
                         isDuplicate = potentialDupes.some(_.isEqual.bind(undefined, datum));
                     }
-                } else if (startIndex === this.boundedTelemetry.length) {
-                    isDuplicate = _.isEqual(datum, this.boundedTelemetry[this.boundedTelemetry.length - 1]);
                 }
 
                 if (!isDuplicate) {
@@ -321,7 +323,7 @@ export class TelemetryCollection extends EventEmitter {
      * Time System
      * @private
      */
-    _setTimeSystem(timeSystem) {
+    _timeSystem(timeSystem) {
         let domains = this.metadata.valuesForHints(['domain']);
         let domain = domains.find((d) => d.key === timeSystem.key);
 
@@ -337,10 +339,7 @@ export class TelemetryCollection extends EventEmitter {
         this.parseTime = (datum) => {
             return valueFormatter.parse(datum);
         };
-    }
 
-    _setTimeSystemAndFetchData(timeSystem) {
-        this._setTimeSystem(timeSystem);
         this._reset();
     }
 
@@ -377,19 +376,19 @@ export class TelemetryCollection extends EventEmitter {
     }
 
     /**
-     * adds the _setTimeSystemAndFetchData callback to the 'timeSystem' timeAPI listener
+     * adds the _timeSystem callback to the 'timeSystem' timeAPI listener
      * @private
      */
     _watchTimeSystem() {
-        this.openmct.time.on('timeSystem', this._setTimeSystemAndFetchData, this);
+        this.openmct.time.on('timeSystem', this._timeSystem, this);
     }
 
     /**
-     * removes the _setTimeSystemAndFetchData callback from the 'timeSystem' timeAPI listener
+     * removes the _timeSystem callback from the 'timeSystem' timeAPI listener
      * @private
      */
     _unwatchTimeSystem() {
-        this.openmct.time.off('timeSystem', this._setTimeSystemAndFetchData, this);
+        this.openmct.time.off('timeSystem', this._timeSystem, this);
     }
 
     /**

src/api/telemetry/TelemetryMetadataManager.js

@@ -31,6 +31,11 @@ define([
         valueMetadata.hints = valueMetadata.hints || {};
 
         if (Object.prototype.hasOwnProperty.call(valueMetadata.hints, 'x')) {
+            console.warn(
+                'DEPRECATION WARNING: `x` hints should be replaced with '
+                + '`domain` hints moving forward.  '
+                + 'https://github.com/nasa/openmct/issues/1546'
+            );
             if (!Object.prototype.hasOwnProperty.call(valueMetadata.hints, 'domain')) {
                 valueMetadata.hints.domain = valueMetadata.hints.x;
             }
@@ -39,6 +44,11 @@ define([
         }
 
         if (Object.prototype.hasOwnProperty.call(valueMetadata.hints, 'y')) {
+            console.warn(
+                'DEPRECATION WARNING: `y` hints should be replaced with '
+                + '`range` hints moving forward.  '
+                + 'https://github.com/nasa/openmct/issues/1546'
+            );
             if (!Object.prototype.hasOwnProperty.call(valueMetadata.hints, 'range')) {
                 valueMetadata.hints.range = valueMetadata.hints.y;
             }

src/api/time/TimeAPI.js

@@ -172,7 +172,7 @@ class TimeAPI extends GlobalTimeContext {
      * @memberof module:openmct.TimeAPI#
      * @method getContextForView
      */
-    getContextForView(objectPath = []) {
+    getContextForView(objectPath) {
         let timeContext = this;
 
         objectPath.forEach(item => {

src/api/types/TypeRegistry.js

@@ -63,6 +63,12 @@ define(['./Type'], function (Type) {
      */
     TypeRegistry.prototype.standardizeType = function (typeDef) {
         if (Object.prototype.hasOwnProperty.call(typeDef, 'label')) {
+            console.warn(
+                'DEPRECATION WARNING typeDef: ' + typeDef.label + '.  '
+                + '`label` is deprecated in type definitions.  Please use '
+                + '`name` instead.  This will cause errors in a future version '
+                + 'of Open MCT.  For more information, see '
+                + 'https://github.com/nasa/openmct/issues/1568');
             if (!typeDef.name) {
                 typeDef.name = typeDef.label;
             }

src/plugins/CouchDBSearchFolder/plugin.js

@@ -1,4 +1,4 @@
-export default function (folderName, couchPlugin, searchFilter, isEditable = false) {
+export default function (folderName, couchPlugin, searchFilter) {
     return function install(openmct) {
         const couchProvider = couchPlugin.couchProvider;
 
@@ -14,9 +14,8 @@ export default function (folderName, couchPlugin, searchFilter, isEditable = fal
                 } else {
                     return Promise.resolve({
                         identifier,
-                        type: isEditable ? 'folder' : 'noneditable.folder',
-                        name: folderName || "CouchDB Documents",
-                        location: 'ROOT'
+                        type: 'folder',
+                        name: folderName || "CouchDB Documents"
                     });
                 }
             }

src/plugins/CouchDBSearchFolder/pluginSpec.js

@@ -24,8 +24,6 @@ import {createOpenMct, resetApplicationState} from "utils/testing";
 import CouchDBSearchFolderPlugin from './plugin';
 
 describe('the plugin', function () {
-    const FOLDER_TYPE = 'folder';
-    const NONEDITABLE_FOLDER_TYPE = 'noneditable.folder';
     let identifier = {
         namespace: 'couch-search',
         key: "couch-search"
@@ -33,13 +31,12 @@ describe('the plugin', function () {
     let testPath = '/test/db';
     let openmct;
     let composition;
-    let couchPlugin;
 
     beforeEach(() => {
 
         openmct = createOpenMct();
 
-        couchPlugin = openmct.plugins.CouchDB(testPath);
+        let couchPlugin = openmct.plugins.CouchDB(testPath);
         openmct.install(couchPlugin);
 
         openmct.install(new CouchDBSearchFolderPlugin('CouchDB Documents', couchPlugin, {
@@ -83,68 +80,20 @@ describe('the plugin', function () {
         return resetApplicationState(openmct);
     });
 
-    describe('provides', () => {
-        const NAME = 'CouchDB Documents';
-
-        beforeEach((done) => {
-            openmct.install(new CouchDBSearchFolderPlugin(NAME, couchPlugin, {
-                "selector": {
-                    "model": {
-                        "type": "plan"
-                    }
-                }
-            }));
-
-            openmct.on('start', done);
-            openmct.startHeadless();
-
-            composition = openmct.composition.get({identifier});
-        });
-
-        it('a default non-editable folder to hold plans', () => {
-            return openmct.objects.get(identifier).then((object) => {
-                expect(object).toEqual({
-                    identifier,
-                    type: NONEDITABLE_FOLDER_TYPE,
-                    name: NAME,
-                    location: "ROOT"
-                });
-            });
-        });
-
-        it('composition for couch search folders', () => {
-            return composition.load().then((objects) => {
-                expect(objects.length).toEqual(2);
+    it('provides a folder to hold plans', () => {
+        return openmct.objects.get(identifier).then((object) => {
+            expect(object).toEqual({
+                identifier,
+                type: 'folder',
+                name: "CouchDB Documents"
             });
         });
     });
 
-    describe('optionally provides', () => {
-        const EDITABLE = true;
-        const NAME = 'Editable CouchDB Documents';
-
-        beforeEach((done) => {
-            openmct.install(new CouchDBSearchFolderPlugin(NAME, couchPlugin, {
-                "selector": {
-                    "model": {
-                        "type": "plan"
-                    }
-                }
-            }, EDITABLE));
-
-            openmct.on('start', done);
-            openmct.startHeadless();
-        });
-
-        it('an editable folder to hold plans', () => {
-            return openmct.objects.get(identifier).then((object) => {
-                expect(object).toEqual({
-                    identifier,
-                    type: FOLDER_TYPE,
-                    name: NAME,
-                    location: "ROOT"
-                });
-            });
+    it('provides composition for couch search folders', () => {
+        return composition.load().then((objects) => {
+            expect(objects.length).toEqual(2);
         });
     });
+
 });

src/plugins/charts/plugin.js

@@ -1,51 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2021, 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 { BAR_GRAPH_KEY } from './BarGraphConstants';
-import BarGraphViewProvider from './BarGraphViewProvider';
-import BarGraphInspectorViewProvider from './inspector/BarGraphInspectorViewProvider';
-import BarGraphCompositionPolicy from './BarGraphCompositionPolicy';
-
-export default function () {
-    return function install(openmct) {
-        openmct.types.addType(BAR_GRAPH_KEY, {
-            key: BAR_GRAPH_KEY,
-            name: "Bar Graph",
-            cssClass: "icon-bar-chart",
-            description: "View data as a bar graph. Can be added to Display Layouts.",
-            creatable: true,
-            initialize: function (domainObject) {
-                domainObject.composition = [];
-                domainObject.configuration = {
-                    barStyles: { series: {} }
-                };
-            },
-            priority: 891
-        });
-
-        openmct.objectViews.addProvider(new BarGraphViewProvider(openmct));
-
-        openmct.inspectorViews.addProvider(new BarGraphInspectorViewProvider(openmct));
-
-        openmct.composition.addPolicy(new BarGraphCompositionPolicy(openmct).allow);
-    };
-}
-

src/plugins/charts/pluginSpec.js

@@ -1,485 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2021, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-
-import {createOpenMct, resetApplicationState} from "utils/testing";
-import Vue from "vue";
-import BarGraphPlugin from "./plugin";
-import BarGraph from './BarGraphPlot.vue';
-import EventEmitter from "EventEmitter";
-import { BAR_GRAPH_VIEW, BAR_GRAPH_KEY } from './BarGraphConstants';
-
-describe("the plugin", function () {
-    let element;
-    let child;
-    let openmct;
-    let telemetryPromise;
-    let telemetryPromiseResolve;
-    let mockObjectPath;
-
-    beforeEach((done) => {
-        mockObjectPath = [
-            {
-                name: 'mock folder',
-                type: 'fake-folder',
-                identifier: {
-                    key: 'mock-folder',
-                    namespace: ''
-                }
-            },
-            {
-                name: 'mock parent folder',
-                type: 'time-strip',
-                identifier: {
-                    key: 'mock-parent-folder',
-                    namespace: ''
-                }
-            }
-        ];
-        const testTelemetry = [
-            {
-                'utc': 1,
-                'some-key': 'some-value 1',
-                'some-other-key': 'some-other-value 1'
-            },
-            {
-                'utc': 2,
-                'some-key': 'some-value 2',
-                'some-other-key': 'some-other-value 2'
-            },
-            {
-                'utc': 3,
-                'some-key': 'some-value 3',
-                'some-other-key': 'some-other-value 3'
-            }
-        ];
-
-        openmct = createOpenMct();
-
-        telemetryPromise = new Promise((resolve) => {
-            telemetryPromiseResolve = resolve;
-        });
-
-        spyOn(openmct.telemetry, 'request').and.callFake(() => {
-            telemetryPromiseResolve(testTelemetry);
-
-            return telemetryPromise;
-        });
-
-        openmct.install(new BarGraphPlugin());
-
-        element = document.createElement("div");
-        element.style.width = "640px";
-        element.style.height = "480px";
-        child = document.createElement("div");
-        child.style.width = "640px";
-        child.style.height = "480px";
-        element.appendChild(child);
-        document.body.appendChild(element);
-
-        spyOn(window, 'ResizeObserver').and.returnValue({
-            observe() {},
-            unobserve() {},
-            disconnect() {}
-        });
-
-        openmct.time.timeSystem("utc", {
-            start: 0,
-            end: 4
-        });
-
-        openmct.types.addType("test-object", {
-            creatable: true
-        });
-
-        openmct.on("start", done);
-        openmct.startHeadless();
-    });
-
-    afterEach((done) => {
-        openmct.time.timeSystem('utc', {
-            start: 0,
-            end: 1
-        });
-        resetApplicationState(openmct).then(done).catch(done);
-    });
-
-    describe("The bar graph view", () => {
-        let testDomainObject;
-        let barGraphObject;
-        // eslint-disable-next-line no-unused-vars
-        let component;
-        let mockComposition;
-
-        beforeEach(async () => {
-            const getFunc = openmct.$injector.get;
-            spyOn(openmct.$injector, "get")
-                .withArgs("exportImageService").and.returnValue({
-                    exportPNG: () => {},
-                    exportJPG: () => {}
-                })
-                .and.callFake(getFunc);
-
-            barGraphObject = {
-                identifier: {
-                    namespace: "",
-                    key: "test-plot"
-                },
-                type: "telemetry.plot.bar-graph",
-                name: "Test Bar Graph"
-            };
-
-            testDomainObject = {
-                identifier: {
-                    namespace: "",
-                    key: "test-object"
-                },
-                configuration: {
-                    barStyles: {
-                        series: {}
-                    }
-                },
-                type: "test-object",
-                name: "Test Object",
-                telemetry: {
-                    values: [{
-                        key: "utc",
-                        format: "utc",
-                        name: "Time",
-                        hints: {
-                            domain: 1
-                        }
-                    }, {
-                        key: "some-key",
-                        name: "Some attribute",
-                        hints: {
-                            range: 1
-                        }
-                    }, {
-                        key: "some-other-key",
-                        name: "Another attribute",
-                        hints: {
-                            range: 2
-                        }
-                    }]
-                }
-            };
-
-            mockComposition = new EventEmitter();
-            mockComposition.load = () => {
-                mockComposition.emit('add', testDomainObject);
-
-                return [testDomainObject];
-            };
-
-            spyOn(openmct.composition, 'get').and.returnValue(mockComposition);
-
-            let viewContainer = document.createElement("div");
-            child.append(viewContainer);
-            component = new Vue({
-                el: viewContainer,
-                components: {
-                    BarGraph
-                },
-                provide: {
-                    openmct: openmct,
-                    domainObject: barGraphObject,
-                    composition: openmct.composition.get(barGraphObject)
-                },
-                template: "<BarGraph></BarGraph>"
-            });
-
-            await Vue.nextTick();
-        });
-
-        it("provides a bar graph view", () => {
-            const applicableViews = openmct.objectViews.get(barGraphObject, mockObjectPath);
-            const plotViewProvider = applicableViews.find((viewProvider) => viewProvider.key === BAR_GRAPH_VIEW);
-            expect(plotViewProvider).toBeDefined();
-        });
-
-        it("Renders plotly bar graph", () => {
-            let barChartElement = element.querySelectorAll(".plotly");
-            expect(barChartElement.length).toBe(1);
-        });
-
-        it("Handles dots in telemetry id", () => {
-            const dotFullTelemetryObject = {
-                identifier: {
-                    namespace: "someNamespace",
-                    key: "~OpenMCT~outer.test-object.foo.bar"
-                },
-                type: "test-dotful-object",
-                name: "A Dotful Object",
-                telemetry: {
-                    values: [{
-                        key: "utc",
-                        format: "utc",
-                        name: "Time",
-                        hints: {
-                            domain: 1
-                        }
-                    }, {
-                        key: "some-key.foo.name.45",
-                        name: "Some dotful attribute",
-                        hints: {
-                            range: 1
-                        }
-                    }, {
-                        key: "some-other-key.bar.344.rad",
-                        name: "Another dotful attribute",
-                        hints: {
-                            range: 2
-                        }
-                    }]
-                }
-            };
-
-            const applicableViews = openmct.objectViews.get(barGraphObject, mockObjectPath);
-            const plotViewProvider = applicableViews.find((viewProvider) => viewProvider.key === BAR_GRAPH_VIEW);
-            const barGraphView = plotViewProvider.view(testDomainObject, [testDomainObject]);
-            barGraphView.show(child, true);
-            expect(testDomainObject.configuration.barStyles.series["test-object"].name).toEqual("Test Object");
-            mockComposition.emit('add', dotFullTelemetryObject);
-            expect(testDomainObject.configuration.barStyles.series["someNamespace:~OpenMCT~outer.test-object.foo.bar"].name).toEqual("A Dotful Object");
-            barGraphView.destroy();
-        });
-    });
-
-    describe("the bar graph objects", () => {
-        const mockObject = {
-            name: 'A very nice bar graph',
-            key: BAR_GRAPH_KEY,
-            creatable: true
-        };
-
-        it('defines a bar graph object type with the correct key', () => {
-            const objectDef = openmct.types.get(BAR_GRAPH_KEY).definition;
-            expect(objectDef.key).toEqual(mockObject.key);
-        });
-
-        it('is creatable', () => {
-            const objectDef = openmct.types.get(BAR_GRAPH_KEY).definition;
-            expect(objectDef.creatable).toEqual(mockObject.creatable);
-        });
-    });
-
-    describe("The bar graph composition policy", () => {
-
-        it("allows composition for telemetry that contain at least one range", () => {
-            const parent = {
-                "composition": [],
-                "configuration": {},
-                "name": "Some Bar Graph",
-                "type": "telemetry.plot.bar-graph",
-                "location": "mine",
-                "modified": 1631005183584,
-                "persisted": 1631005183502,
-                "identifier": {
-                    "namespace": "",
-                    "key": "b78e7e23-f2b8-4776-b1f0-3ff778f5c8a9"
-                }
-            };
-            const testTelemetryObject = {
-                identifier: {
-                    namespace: "",
-                    key: "test-object"
-                },
-                type: "test-object",
-                name: "Test Object",
-                telemetry: {
-                    values: [{
-                        key: "some-key",
-                        name: "Some attribute",
-                        hints: {
-                            domain: 1
-                        }
-                    }, {
-                        key: "some-other-key",
-                        name: "Another attribute",
-                        hints: {
-                            range: 1
-                        }
-                    }]
-                }
-            };
-            const composition = openmct.composition.get(parent);
-            expect(() => {
-                composition.add(testTelemetryObject);
-            }).not.toThrow();
-            expect(parent.composition.length).toBe(1);
-        });
-
-        it("disallows composition for telemetry that don't contain any range hints", () => {
-            const parent = {
-                "composition": [],
-                "configuration": {},
-                "name": "Some Bar Graph",
-                "type": "telemetry.plot.bar-graph",
-                "location": "mine",
-                "modified": 1631005183584,
-                "persisted": 1631005183502,
-                "identifier": {
-                    "namespace": "",
-                    "key": "b78e7e23-f2b8-4776-b1f0-3ff778f5c8a9"
-                }
-            };
-            const testTelemetryObject = {
-                identifier: {
-                    namespace: "",
-                    key: "test-object"
-                },
-                type: "test-object",
-                name: "Test Object",
-                telemetry: {
-                    values: [{
-                        key: "some-key",
-                        name: "Some attribute"
-                    }, {
-                        key: "some-other-key",
-                        name: "Another attribute"
-                    }]
-                }
-            };
-            const composition = openmct.composition.get(parent);
-            expect(() => {
-                composition.add(testTelemetryObject);
-            }).toThrow();
-            expect(parent.composition.length).toBe(0);
-        });
-    });
-    describe('the inspector view', () => {
-        let mockComposition;
-        let testDomainObject;
-        let selection;
-        let plotInspectorView;
-        let viewContainer;
-        let optionsElement;
-        beforeEach(async () => {
-            testDomainObject = {
-                identifier: {
-                    namespace: "",
-                    key: "test-object"
-                },
-                type: "test-object",
-                name: "Test Object",
-                telemetry: {
-                    values: [{
-                        key: "utc",
-                        format: "utc",
-                        name: "Time",
-                        hints: {
-                            domain: 1
-                        }
-                    }, {
-                        key: "some-key",
-                        name: "Some attribute",
-                        hints: {
-                            range: 1
-                        }
-                    }, {
-                        key: "some-other-key",
-                        name: "Another attribute",
-                        hints: {
-                            range: 2
-                        }
-                    }]
-                }
-            };
-
-            selection = [
-                [
-                    {
-                        context: {
-                            item: {
-                                id: "test-object",
-                                identifier: {
-                                    key: "test-object",
-                                    namespace: ''
-                                },
-                                type: "telemetry.plot.bar-graph",
-                                configuration: {
-                                    barStyles: {
-                                        series: {
-                                            '~Some~foo.bar': {
-                                                name: 'A telemetry object',
-                                                type: 'some-type',
-                                                isAlias: true
-                                            }
-                                        }
-                                    }
-                                },
-                                composition: [
-                                    {
-                                        key: '~Some~foo.bar'
-                                    }
-                                ]
-                            }
-                        }
-                    },
-                    {
-                        context: {
-                            item: {
-                                type: 'time-strip',
-                                identifier: {
-                                    key: 'some-other-key',
-                                    namespace: ''
-                                }
-                            }
-                        }
-                    }
-                ]
-            ];
-
-            mockComposition = new EventEmitter();
-            mockComposition.load = () => {
-                mockComposition.emit('add', testDomainObject);
-
-                return [testDomainObject];
-            };
-
-            spyOn(openmct.composition, 'get').and.returnValue(mockComposition);
-
-            viewContainer = document.createElement('div');
-            child.append(viewContainer);
-
-            const applicableViews = openmct.inspectorViews.get(selection);
-            plotInspectorView = applicableViews[0];
-            plotInspectorView.show(viewContainer);
-
-            await Vue.nextTick();
-            optionsElement = element.querySelector('.c-bar-graph-options');
-        });
-
-        afterEach(() => {
-            plotInspectorView.destroy();
-        });
-
-        it('it renders the options', () => {
-            expect(optionsElement).toBeDefined();
-        });
-
-        it('shows the name', () => {
-            const seriesEl = optionsElement.querySelector('.c-object-label__name');
-            expect(seriesEl.innerHTML).toEqual('A telemetry object');
-        });
-    });
-});

src/plugins/clearData/plugin.js

@@ -47,9 +47,7 @@ define([
                 });
 
                 let indicator = {
-                    element: component.$mount().$el,
-                    key: 'clear-data-indicator',
-                    priority: openmct.priority.DEFAULT
+                    element: component.$mount().$el
                 };
 
                 openmct.indicators.add(indicator);

src/plugins/clearData/test/ClearDataActionSpec.js

@@ -41,9 +41,6 @@ describe('When the Clear Data Plugin is installed,', () => {
     const openmct = {
         objectViews: mockObjectViews,
         indicators: mockIndicatorProvider,
-        priority: {
-            DEFAULT: 0
-        },
         actions: mockActionsProvider,
         install: function (plugin) {
             plugin(this);
@@ -72,13 +69,13 @@ describe('When the Clear Data Plugin is installed,', () => {
     ];
 
     it('Global Clear Indicator is installed', () => {
-        openmct.install(ClearDataActionPlugin(openmct, {indicator: true}));
+        openmct.install(ClearDataActionPlugin([]));
 
         expect(mockIndicatorProvider.add).toHaveBeenCalled();
     });
 
     it('Clear Data context menu action is installed', () => {
-        openmct.install(ClearDataActionPlugin(openmct, []));
+        openmct.install(ClearDataActionPlugin([]));
 
         expect(mockActionsProvider.register).toHaveBeenCalled();
     });

src/plugins/clock/plugin.js

@@ -116,8 +116,7 @@ export default function ClockPlugin(options) {
             });
             const indicator = {
                 element: clockIndicator.$mount().$el,
-                key: 'clock-indicator',
-                priority: openmct.priority.LOW
+                key: 'clock-indicator'
             };
 
             openmct.indicators.add(indicator);

src/plugins/condition/Condition.js

@@ -65,7 +65,7 @@ export default class Condition extends EventEmitter {
         }
 
         this.trigger = conditionConfiguration.configuration.trigger;
-        this.summary = '';
+        this.description = '';
     }
 
     updateResult(datum) {
@@ -134,6 +134,7 @@ export default class Condition extends EventEmitter {
         criterionConfigurations.forEach((criterionConfiguration) => {
             this.addCriterion(criterionConfiguration);
         });
+        this.updateDescription();
     }
 
     updateCriteria(criterionConfigurations) {
@@ -145,6 +146,7 @@ export default class Condition extends EventEmitter {
         this.criteria.forEach((criterion) => {
             criterion.updateTelemetryObjects(this.conditionManager.telemetryObjects);
         });
+        this.updateDescription();
     }
 
     /**
@@ -198,6 +200,7 @@ export default class Condition extends EventEmitter {
             criterion.off('criterionUpdated', (obj) => this.handleCriterionUpdated(obj));
             criterion.off('telemetryIsStale', (obj) => this.handleStaleCriterion(obj));
             this.criteria.splice(found.index, 1, newCriterion);
+            this.updateDescription();
         }
     }
 
@@ -213,6 +216,7 @@ export default class Condition extends EventEmitter {
             });
             criterion.destroy();
             this.criteria.splice(found.index, 1);
+            this.updateDescription();
 
             return true;
         }
@@ -224,6 +228,7 @@ export default class Condition extends EventEmitter {
         let found = this.findCriterion(criterion.id);
         if (found) {
             this.criteria[found.index] = criterion.data;
+            this.updateDescription();
         }
     }
 
@@ -249,7 +254,8 @@ export default class Condition extends EventEmitter {
 
             description = `${description} ${criterion.getDescription()} ${(index < this.criteria.length - 1) ? triggerDescription.conjunction : ''}`;
         });
-        this.summary = description;
+        this.description = description;
+        this.conditionManager.updateConditionDescription(this);
     }
 
     getTriggerDescription() {

src/plugins/condition/ConditionManager.js

@@ -105,14 +105,7 @@ export default class ConditionManager extends EventEmitter {
     }
 
     updateConditionTelemetryObjects() {
-        this.conditions.forEach((condition) => {
-            condition.updateTelemetryObjects();
-            let index = this.conditionSetDomainObject.configuration.conditionCollection.findIndex(item => item.id === condition.id);
-            if (index > -1) {
-                //Only assign the summary, don't mutate the domain object
-                this.conditionSetDomainObject.configuration.conditionCollection[index].summary = this.updateConditionDescription(condition);
-            }
-        });
+        this.conditions.forEach((condition) => condition.updateTelemetryObjects());
     }
 
     removeConditionTelemetryObjects() {
@@ -146,17 +139,10 @@ export default class ConditionManager extends EventEmitter {
         }
     }
 
-    updateConditionDescription(condition) {
-        condition.updateDescription();
-
-        return condition.summary;
-    }
-
     updateCondition(conditionConfiguration) {
         let condition = this.findConditionById(conditionConfiguration.id);
         if (condition) {
             condition.update(conditionConfiguration);
-            conditionConfiguration.summary = this.updateConditionDescription(condition);
         }
 
         let index = this.conditionSetDomainObject.configuration.conditionCollection.findIndex(item => item.id === conditionConfiguration.id);
@@ -166,10 +152,16 @@ export default class ConditionManager extends EventEmitter {
         }
     }
 
+    updateConditionDescription(condition) {
+        const found = this.conditionSetDomainObject.configuration.conditionCollection.find(conditionConfiguration => (conditionConfiguration.id === condition.id));
+        if (found.summary !== condition.description) {
+            found.summary = condition.description;
+            this.persistConditions();
+        }
+    }
+
     initCondition(conditionConfiguration, index) {
         let condition = new Condition(conditionConfiguration, this.openmct, this);
-        conditionConfiguration.summary = this.updateConditionDescription(condition);
-
         if (index !== undefined) {
             this.conditions.splice(index + 1, 0, condition);
         } else {

src/plugins/condition/ConditionSetViewProvider.js

@@ -33,10 +33,8 @@ export default class ConditionSetViewProvider {
         this.cssClass = 'icon-conditional';
     }
 
-    canView(domainObject, objectPath) {
-        const isConditionSet = domainObject.type === 'conditionSet';
-
-        return isConditionSet && this.openmct.router.isNavigatedObject(objectPath);
+    canView(domainObject) {
+        return domainObject.type === 'conditionSet';
     }
 
     canEdit(domainObject) {

src/plugins/condition/components/Criterion.vue

@@ -244,7 +244,7 @@ export default {
                 this.telemetryMetadataOptions = [];
                 telemetryObjects.forEach(telemetryObject => {
                     let telemetryMetadata = this.openmct.telemetry.getMetadata(telemetryObject);
-                    this.addMetaDataOptions(telemetryMetadata ? telemetryMetadata.values() : []);
+                    this.addMetaDataOptions(telemetryMetadata.values());
                 });
                 this.updateOperations();
             }

src/plugins/condition/components/TestData.vue

@@ -192,11 +192,7 @@ export default {
             this.telemetry.forEach((telemetryObject) => {
                 const id = this.openmct.objects.makeKeyString(telemetryObject.identifier);
                 let telemetryMetadata = this.openmct.telemetry.getMetadata(telemetryObject);
-                if (telemetryMetadata) {
-                    this.telemetryMetadataOptions[id] = telemetryMetadata.values().slice();
-                } else {
-                    this.telemetryMetadataOptions[id] = [];
-                }
+                this.telemetryMetadataOptions[id] = telemetryMetadata.values().slice();
             });
         },
         addTestInput(testInput) {

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

@@ -30,10 +30,10 @@
             <div v-if="staticStyle"
                  class="c-inspect-styles__style"
             >
-                <StyleEditor class="c-inspect-styles__editor"
-                             :style-item="staticStyle"
-                             :is-editing="isEditing"
-                             @persist="updateStaticStyle"
+                <style-editor class="c-inspect-styles__editor"
+                              :style-item="staticStyle"
+                              :is-editing="isEditing"
+                              @persist="updateStaticStyle"
                 />
             </div>
             <button
@@ -87,10 +87,10 @@
                 <condition-description :show-label="true"
                                        :condition="getCondition(conditionStyle.conditionId)"
                 />
-                <StyleEditor class="c-inspect-styles__editor"
-                             :style-item="conditionStyle"
-                             :is-editing="isEditing"
-                             @persist="updateConditionalStyle"
+                <style-editor class="c-inspect-styles__editor"
+                              :style-item="conditionStyle"
+                              :is-editing="isEditing"
+                              @persist="updateConditionalStyle"
                 />
             </div>
         </div>
@@ -240,10 +240,10 @@ export default {
             }
 
             let vm = new Vue({
-                components: {ConditionSetSelectorDialog},
                 provide: {
                     openmct: this.openmct
                 },
+                components: {ConditionSetSelectorDialog},
                 data() {
                     return {
                         handleItemSelection

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

@@ -40,13 +40,13 @@
             <div v-if="staticStyle"
                  class="c-inspect-styles__style"
             >
-                <StyleEditor class="c-inspect-styles__editor"
-                             :style-item="staticStyle"
-                             :is-editing="allowEditing"
-                             :mixed-styles="mixedStyles"
-                             :non-specific-font-properties="nonSpecificFontProperties"
-                             @persist="updateStaticStyle"
-                             @save-style="saveStyle"
+                <style-editor class="c-inspect-styles__editor"
+                              :style-item="staticStyle"
+                              :is-editing="allowEditing"
+                              :mixed-styles="mixedStyles"
+                              :non-specific-font-properties="nonSpecificFontProperties"
+                              @persist="updateStaticStyle"
+                              @save-style="saveStyle"
                 />
             </div>
             <button
@@ -108,12 +108,12 @@
                 <condition-description :show-label="true"
                                        :condition="getCondition(conditionStyle.conditionId)"
                 />
-                <StyleEditor class="c-inspect-styles__editor"
-                             :style-item="conditionStyle"
-                             :non-specific-font-properties="nonSpecificFontProperties"
-                             :is-editing="allowEditing"
-                             @persist="updateConditionalStyle"
-                             @save-style="saveStyle"
+                <style-editor class="c-inspect-styles__editor"
+                              :style-item="conditionStyle"
+                              :non-specific-font-properties="nonSpecificFontProperties"
+                              :is-editing="allowEditing"
+                              @persist="updateConditionalStyle"
+                              @save-style="saveStyle"
                 />
             </div>
         </div>
@@ -556,10 +556,10 @@ export default {
             }
 
             let vm = new Vue({
-                components: {ConditionSetSelectorDialog},
                 provide: {
                     openmct: this.openmct
                 },
+                components: {ConditionSetSelectorDialog},
                 data() {
                     return {
                         handleItemSelection

src/plugins/condition/criterion/AllTelemetryCriterion.js

@@ -177,7 +177,7 @@ export default class AllTelemetryCriterion extends TelemetryCriterion {
                 const timeSystem = this.openmct.time.timeSystem();
 
                 telemetryRequestsResults.forEach((results, index) => {
-                    const latestDatum = (Array.isArray(results) && results.length) ? results[results.length - 1] : {};
+                    const latestDatum = results.length ? results[results.length - 1] : {};
                     const datumId = keys[index];
                     const normalizedDatum = this.createNormalizedDatum(latestDatum, telemetryObjects[datumId]);
 

src/plugins/condition/criterion/TelemetryCriterion.js

@@ -167,11 +167,6 @@ export default class TelemetryCriterion extends EventEmitter {
                 id: this.id,
                 data: this.formatData(normalizedDatum)
             };
-        }).catch((error) => {
-            return {
-                id: this.id,
-                data: this.formatData()
-            };
         });
     }
 

src/plugins/condition/pluginSpec.js

@@ -27,7 +27,6 @@ import StylesView from "./components/inspector/StylesView.vue";
 import Vue from 'vue';
 import {getApplicableStylesForItem} from "./utils/styleUtils";
 import ConditionManager from "@/plugins/condition/ConditionManager";
-import StyleRuleManager from "./StyleRuleManager";
 
 describe('the plugin', function () {
     let conditionSetDefinition;
@@ -97,8 +96,6 @@ describe('the plugin', function () {
 
         mockListener = jasmine.createSpy('mockListener');
 
-        openmct.router.isNavigatedObject = jasmine.createSpy().and.returnValue(true);
-
         conditionSetDefinition.initialize(mockConditionSetDomainObject);
 
         spyOn(openmct.objects, "save").and.returnValue(Promise.resolve(true));
@@ -131,6 +128,21 @@ describe('the plugin', function () {
             expect(mockConditionSetDomainObject.composition instanceof Array).toBeTrue();
             expect(mockConditionSetDomainObject.composition.length).toEqual(0);
         });
+
+        it('provides a view', () => {
+            const testViewObject = {
+                id: "test-object",
+                type: "conditionSet",
+                configuration: {
+                    conditionCollection: []
+                }
+            };
+
+            const applicableViews = openmct.objectViews.get(testViewObject, []);
+            let conditionSetView = applicableViews.find((viewProvider) => viewProvider.key === 'conditionSet.view');
+            expect(conditionSetView).toBeDefined();
+        });
+
     });
 
     describe('the condition set usage for multiple display layout items', () => {
@@ -712,124 +724,4 @@ describe('the plugin', function () {
             expect(result[2]).toBeUndefined();
         });
     });
-
-    describe('canView of ConditionSetViewProvider', () => {
-        let conditionSetView;
-        const testViewObject = {
-            id: "test-object",
-            type: "conditionSet",
-            configuration: {
-                conditionCollection: []
-            }
-        };
-
-        beforeEach(() => {
-            const applicableViews = openmct.objectViews.get(testViewObject, []);
-            conditionSetView = applicableViews.find((viewProvider) => viewProvider.key === 'conditionSet.view');
-        });
-
-        it('provides a view', () => {
-            expect(conditionSetView).toBeDefined();
-        });
-
-        it('returns true for type `conditionSet` and is a navigated Object', () => {
-            openmct.router.isNavigatedObject = jasmine.createSpy().and.returnValue(true);
-
-            const isCanView = conditionSetView.canView(testViewObject, []);
-
-            expect(isCanView).toBe(true);
-        });
-
-        it('returns false for type `conditionSet` and is not a navigated Object', () => {
-            openmct.router.isNavigatedObject = jasmine.createSpy().and.returnValue(false);
-
-            const isCanView = conditionSetView.canView(testViewObject, []);
-
-            expect(isCanView).toBe(false);
-        });
-
-        it('returns false for type `notConditionSet` and is a navigated Object', () => {
-            openmct.router.isNavigatedObject = jasmine.createSpy().and.returnValue(true);
-            testViewObject.type = 'notConditionSet';
-            const isCanView = conditionSetView.canView(testViewObject, []);
-
-            expect(isCanView).toBe(false);
-        });
-    });
-
-    describe('The Style Rule Manager', () => {
-        it('should subscribe to the conditionSet after the editor saves', async () => {
-            const stylesObject = {
-                "styles": [
-                    {
-                        "conditionId": "a8bf7d1a-c1bb-4fc7-936a-62056a51b5cd",
-                        "style": {
-                            "backgroundColor": "#38761d",
-                            "border": "",
-                            "color": "#073763",
-                            "isStyleInvisible": ""
-                        }
-                    },
-                    {
-                        "conditionId": "0558fa77-9bdc-4142-9f9a-7a28fe95182e",
-                        "style": {
-                            "backgroundColor": "#980000",
-                            "border": "",
-                            "color": "#ff9900",
-                            "isStyleInvisible": ""
-                        }
-                    }
-                ],
-                "staticStyle": {
-                    "style": {
-                        "backgroundColor": "",
-                        "border": "",
-                        "color": ""
-                    }
-                },
-                "selectedConditionId": "0558fa77-9bdc-4142-9f9a-7a28fe95182e",
-                "defaultConditionId": "0558fa77-9bdc-4142-9f9a-7a28fe95182e",
-                "conditionSetIdentifier": {
-                    "namespace": "",
-                    "key": "035c589c-d98f-429e-8b89-d76bd8d22b29"
-                }
-            };
-            openmct.$injector = jasmine.createSpyObj('$injector', ['get']);
-            // const mockTransactionService = jasmine.createSpyObj(
-            //     'transactionService',
-            //     ['commit']
-            // );
-            openmct.telemetry = jasmine.createSpyObj('telemetry', ['isTelemetryObject', "subscribe", "getMetadata", "getValueFormatter", "request"]);
-            openmct.telemetry.isTelemetryObject.and.returnValue(true);
-            openmct.telemetry.subscribe.and.returnValue(function () {});
-            openmct.telemetry.getValueFormatter.and.returnValue({
-                parse: function (value) {
-                    return value;
-                }
-            });
-            openmct.telemetry.getMetadata.and.returnValue(testTelemetryObject.telemetry);
-            openmct.telemetry.request.and.returnValue(Promise.resolve([]));
-
-            // mockTransactionService.commit = async () => {};
-            const mockIdentifierService = jasmine.createSpyObj(
-                'identifierService',
-                ['parse']
-            );
-            mockIdentifierService.parse.and.returnValue({
-                getSpace: () => {
-                    return '';
-                }
-            });
-
-            openmct.$injector = jasmine.createSpyObj('$injector', ['get']);
-            openmct.$injector.get.withArgs('identifierService').and.returnValue(mockIdentifierService);
-            // .withArgs('transactionService').and.returnValue(mockTransactionService);
-
-            const styleRuleManger = new StyleRuleManager(stylesObject, openmct, null, true);
-            spyOn(styleRuleManger, 'subscribeToConditionSet');
-            openmct.editor.edit();
-            await openmct.editor.save();
-            expect(styleRuleManger.subscribeToConditionSet).toHaveBeenCalledTimes(1);
-        });
-    });
 });

src/plugins/conditionWidget/components/ConditionWidget.vue

@@ -23,7 +23,7 @@
 <template>
 <component :is="urlDefined ? 'a' : 'span'"
            class="c-condition-widget u-style-receiver js-style-receiver"
-           :href="url"
+           :href="urlDefined ? internalDomainObject.url : null"
 >
     <div class="c-condition-widget__label">
         {{ internalDomainObject.label }}
@@ -32,8 +32,6 @@
 </template>
 
 <script>
-const sanitizeUrl = require("@braintree/sanitize-url").sanitizeUrl;
-
 export default {
     inject: ['openmct', 'domainObject'],
     data: function () {
@@ -44,9 +42,6 @@ export default {
     computed: {
         urlDefined() {
             return this.internalDomainObject.url && this.internalDomainObject.url.length > 0;
-        },
-        url() {
-            return this.urlDefined ? sanitizeUrl(this.internalDomainObject.url) : null;
         }
     },
     mounted() {

src/plugins/conditionWidget/components/condition-widget.scss

@@ -38,16 +38,12 @@ a.c-condition-widget {
 
 // Make Condition Widget expand when in a hidden frame Layout context
 // For both static and Flexible Layouts
-.c-so-view--conditionWidget.c-so-view--no-frame {
-    .c-condition-widget {
-        @include abs();
-        display: flex;
-        align-items: center;
-        justify-content: center;
-        padding: 0;
-    }
-
-    .c-so-view__frame-controls { display: none; }
+.c-so-view--no-frame > .c-so-view__object-view > .c-condition-widget {
+    @include abs();
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    padding: 0;
 }
 
 // Add some margin when a Condition Widget is in a Flexible Layout

src/plugins/displayLayout/components/display-layout.scss

@@ -47,8 +47,8 @@
 
 .is-editing {
     .l-shell__main-container {
-        [s-selected],
-        [s-selected-parent] {
+        &[s-selected],
+        &[s-selected-parent] {
             // Display grid and allow edit marquee to display in main layout holder when editing
             > .l-layout {
                 background: $editUIGridColorBg;

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

@@ -3,7 +3,6 @@
     display: flex;
     flex-flow: column nowrap;
     overflow: auto;
-    height: 100%;
 
     &__item {
         flex: 0 0 auto;

src/plugins/hyperlink/HyperlinkLayout.vue

@@ -27,7 +27,7 @@
        'c-hyperlink--button' : isButton
    }"
    :target="domainObject.linkTarget"
-   :href="url"
+   :href="domainObject.url"
 >
     <span class="c-hyperlink__label">{{ domainObject.displayText }}</span>
 </a>
@@ -35,7 +35,6 @@
 </template>
 
 <script>
-const sanitizeUrl = require("@braintree/sanitize-url").sanitizeUrl;
 
 export default {
     inject: ['domainObject'],
@@ -46,9 +45,6 @@ export default {
             }
 
             return true;
-        },
-        url() {
-            return sanitizeUrl(this.domainObject.url);
         }
     }
 };

src/plugins/imagery/ImageryTimestripViewProvider.js

@@ -66,10 +66,6 @@ export default function ImageryTimestripViewProvider(openmct) {
                 destroy: function () {
                     component.$destroy();
                     component = undefined;
-                },
-
-                getComponent() {
-                    return component;
                 }
             };
         }

src/plugins/imagery/ImageryView.js

@@ -10,14 +10,7 @@ export default class ImageryView {
         this.component = undefined;
     }
 
-    show(element, isEditing, viewOptions) {
-        let alternateObjectPath;
-        let indexForFocusedImage;
-        if (viewOptions) {
-            indexForFocusedImage = viewOptions.indexForFocusedImage;
-            alternateObjectPath = viewOptions.objectPath;
-        }
-
+    show(element) {
         this.component = new Vue({
             el: element,
             components: {
@@ -26,15 +19,10 @@ export default class ImageryView {
             provide: {
                 openmct: this.openmct,
                 domainObject: this.domainObject,
-                objectPath: alternateObjectPath || this.objectPath,
+                objectPath: this.objectPath,
                 currentView: this
             },
-            data() {
-                return {
-                    indexForFocusedImage
-                };
-            },
-            template: '<imagery-view :index-for-focused-image="indexForFocusedImage" ref="ImageryContainer"></imagery-view>'
+            template: '<imagery-view ref="ImageryContainer"></imagery-view>'
 
         });
     }

src/plugins/imagery/components/Compass/pluginSpec.js

@@ -39,13 +39,10 @@ describe("The Compass component", () => {
             sunAngle: 30
         };
         let propsData = {
+            containerWidth: 600,
+            containerHeight: 600,
             naturalAspectRatio: 0.9,
-            image: imageDatum,
-            sizedImageDimensions: {
-                width: 100,
-                height: 100
-            },
-            compassRoseSizingClasses: '--rose-small --rose-min'
+            image: imageDatum
         };
 
         app = new Vue({
@@ -54,13 +51,13 @@ describe("The Compass component", () => {
                 return propsData;
             },
             template: `<Compass
-                :compass-rose-sizing-classes="compassRoseSizingClasses"
-                :image="image"
+                :container-width="containerWidth"
+                :container-height="containerHeight"
                 :natural-aspect-ratio="naturalAspectRatio"
-                :sized-image-dimensions="sizedImageDimensions"
-            />`
+                :image="image" />`
         });
         instance = app.$mount();
+
     });
 
     afterAll(() => {

src/plugins/imagery/components/ImageryTimeView.vue

@@ -41,12 +41,7 @@ import _ from "lodash";
 
 const PADDING = 1;
 const ROW_HEIGHT = 100;
-const IMAGE_SIZE = 85;
-const IMAGE_WIDTH_THRESHOLD = 25;
-const CONTAINER_CLASS = 'c-imagery-tsv-container';
-const NO_ITEMS_CLASS = 'c-imagery-tsv__no-items';
-const IMAGE_WRAPPER_CLASS = 'c-imagery-tsv__image-wrapper';
-const ID_PREFIX = 'wrapper-';
+const IMAGE_WIDTH_THRESHOLD = 40;
 
 export default {
     mixins: [imageryData],
@@ -83,13 +78,11 @@ export default {
         this.canvasContext = this.canvas.getContext('2d');
         this.setDimensions();
 
-        this.setScaleAndPlotImagery = this.setScaleAndPlotImagery.bind(this);
-        this.updateViewBounds = this.updateViewBounds.bind(this);
-        this.setTimeContext = this.setTimeContext.bind(this);
-        this.setTimeContext();
-
         this.updateViewBounds();
 
+        this.openmct.time.on("timeSystem", this.setScaleAndPlotImagery);
+        this.openmct.time.on("bounds", this.updateViewBounds);
+
         this.resize = _.debounce(this.resize, 400);
         this.imageryStripResizeObserver = new ResizeObserver(this.resize);
         this.imageryStripResizeObserver.observe(this.$refs.imagery);
@@ -97,36 +90,25 @@ export default {
         this.unlisten = this.openmct.objects.observe(this.domainObject, '*', this.observeForChanges);
     },
     beforeDestroy() {
+        if (this.unsubscribe) {
+            this.unsubscribe();
+            delete this.unsubscribe;
+        }
+
         if (this.imageryStripResizeObserver) {
             this.imageryStripResizeObserver.disconnect();
         }
 
-        this.stopFollowingTimeContext();
+        this.openmct.time.off("timeSystem", this.setScaleAndPlotImagery);
+        this.openmct.time.off("bounds", this.updateViewBounds);
         if (this.unlisten) {
             this.unlisten();
         }
     },
     methods: {
-        setTimeContext() {
-            this.stopFollowingTimeContext();
-            this.timeContext = this.openmct.time.getContextForView(this.objectPath);
-            this.timeContext.on("timeSystem", this.setScaleAndPlotImagery);
-            this.timeContext.on("bounds", this.updateViewBounds);
-            this.timeContext.on("timeContext", this.setTimeContext);
-        },
-        stopFollowingTimeContext() {
-            if (this.timeContext) {
-                this.timeContext.off("timeSystem", this.setScaleAndPlotImagery);
-                this.timeContext.off("bounds", this.updateViewBounds);
-                this.timeContext.off("timeContext", this.setTimeContext);
-            }
-        },
         expand(index) {
             const path = this.objectPath[0];
-            this.previewAction.invoke([path], {
-                indexForFocusedImage: index,
-                objectPath: this.objectPath
-            });
+            this.previewAction.invoke([path]);
         },
         observeForChanges(mutatedObject) {
             this.updateViewBounds();
@@ -152,10 +134,14 @@ export default {
             return clientWidth;
         },
         updateViewBounds(bounds, isTick) {
-            this.viewBounds = this.timeContext.bounds();
+            this.viewBounds = this.openmct.time.bounds();
+            //Add a 50% padding to the end bounds to look ahead
+            let timespan = (this.viewBounds.end - this.viewBounds.start);
+            let padding = timespan / 2;
+            this.viewBounds.end = this.viewBounds.end + padding;
 
             if (this.timeSystem === undefined) {
-                this.timeSystem = this.timeContext.timeSystem();
+                this.timeSystem = this.openmct.time.timeSystem();
             }
 
             this.setScaleAndPlotImagery(this.timeSystem, !isTick);
@@ -186,18 +172,18 @@ export default {
         },
         clearPreviousImagery(clearAllImagery) {
             //TODO: Only clear items that are out of bounds
-            let noItemsEl = this.$el.querySelectorAll(`.${NO_ITEMS_CLASS}`);
+            let noItemsEl = this.$el.querySelectorAll(".c-imagery-tsv__no-items");
             noItemsEl.forEach(item => {
                 item.remove();
             });
-            let imagery = this.$el.querySelectorAll(`.${IMAGE_WRAPPER_CLASS}`);
+            let imagery = this.$el.querySelectorAll(".c-imagery-tsv__image-wrapper");
             imagery.forEach(item => {
                 if (clearAllImagery) {
                     item.remove();
                 } else {
-                    const id = item.getAttributeNS(null, 'id');
+                    const id = this.getNSAttributesForElement(item, 'id');
                     if (id) {
-                        const timestamp = id.replace(ID_PREFIX, '');
+                        const timestamp = id.replace('id-', '');
                         if (!this.isImageryInBounds({
                             time: timestamp
                         })) {
@@ -219,7 +205,7 @@ export default {
             }
 
             if (timeSystem === undefined) {
-                timeSystem = this.timeContext.timeSystem();
+                timeSystem = this.openmct.time.timeSystem();
             }
 
             if (timeSystem.isUTCBased) {
@@ -237,17 +223,19 @@ export default {
             this.xScale.range([PADDING, this.width - PADDING * 2]);
         },
         isImageryInBounds(imageObj) {
-            return (imageObj.time <= this.viewBounds.end) && (imageObj.time >= this.viewBounds.start);
+            return (imageObj.time < this.viewBounds.end) && (imageObj.time > this.viewBounds.start);
         },
         getImageryContainer() {
-            let containerHeight = 100;
-            let containerWidth = this.imageHistory.length ? this.width : 200;
-            let imageryContainer;
+            let svgHeight = 100;
+            let svgWidth = this.imageHistory.length ? this.width : 200;
+            let groupSVG;
 
-            let existingContainer = this.$el.querySelector(`.${CONTAINER_CLASS}`);
-            if (existingContainer) {
-                imageryContainer = existingContainer;
-                imageryContainer.style.maxWidth = `${containerWidth}px`;
+            let existingSVG = this.$el.querySelector(".c-imagery-tsv__contents svg");
+            if (existingSVG) {
+                groupSVG = existingSVG;
+                this.setNSAttributesForElement(groupSVG, {
+                    width: svgWidth
+                });
             } else {
                 let component = new Vue({
                     components: {
@@ -258,20 +246,26 @@ export default {
                     },
                     data() {
                         return {
-                            isNested: true
+                            isNested: true,
+                            height: svgHeight,
+                            width: svgWidth
                         };
                     },
-                    template: `<swim-lane :is-nested="isNested" :hide-label="true"><template slot="object"><div class="c-imagery-tsv-container"></div></template></swim-lane>`
+                    template: `<swim-lane :is-nested="isNested" :hide-label="true"><template slot="object"><svg class="c-imagery-tsv-container" :height="height" :width="width"></svg></template></swim-lane>`
                 });
 
                 this.$refs.imageryHolder.appendChild(component.$mount().$el);
 
-                imageryContainer = component.$el.querySelector(`.${CONTAINER_CLASS}`);
-                imageryContainer.style.maxWidth = `${containerWidth}px`;
-                imageryContainer.style.height = `${containerHeight}px`;
+                groupSVG = component.$el.querySelector('svg');
+
+                groupSVG.addEventListener('mouseout', (event) => {
+                    if (event.target.nodeName === 'svg' || event.target.nodeName === 'use') {
+                        this.removeFromForeground();
+                    }
+                });
             }
 
-            return imageryContainer;
+            return groupSVG;
         },
         isImageryWidthAcceptable() {
             // We're calculating if there is enough space between images to show the thumbnails.
@@ -287,123 +281,194 @@ export default {
             return imageContainerWidth < IMAGE_WIDTH_THRESHOLD;
         },
         drawImagery() {
-            let imageryContainer = this.getImageryContainer();
+            let groupSVG = this.getImageryContainer();
             const showImagePlaceholders = this.isImageryWidthAcceptable();
-            let index = 0;
+
             if (this.imageHistory.length) {
-                this.imageHistory.forEach((currentImageObject) => {
+                this.imageHistory.forEach((currentImageObject, index) => {
                     if (this.isImageryInBounds(currentImageObject)) {
-                        this.plotImagery(currentImageObject, showImagePlaceholders, imageryContainer, index);
-                        index = index + 1;
+                        this.plotImagery(currentImageObject, showImagePlaceholders, groupSVG, index);
                     }
                 });
             } else {
-                this.plotNoItems(imageryContainer);
+                this.plotNoItems(groupSVG);
             }
         },
-        plotNoItems(containerElement) {
-            let textElement = document.createElement('text');
-            textElement.classList.add(NO_ITEMS_CLASS);
+        plotNoItems(svgElement) {
+            let textElement = document.createElementNS('http://www.w3.org/2000/svg', 'text');
+            this.setNSAttributesForElement(textElement, {
+                x: "10",
+                y: "20",
+                class: "c-imagery-tsv__no-items"
+            });
             textElement.innerHTML = 'No images within timeframe';
 
-            containerElement.appendChild(textElement);
+            svgElement.appendChild(textElement);
         },
         setNSAttributesForElement(element, attributes) {
-            if (!element) {
-                return;
-            }
-
             Object.keys(attributes).forEach((key) => {
-                element.setAttributeNS(null, key, attributes[key]);
+                if (key === 'url') {
+                    element.setAttributeNS('http://www.w3.org/1999/xlink', 'href', attributes[key]);
+                } else {
+                    element.setAttributeNS(null, key, attributes[key]);
+                }
             });
         },
-        setStyles(element, styles) {
-            if (!element) {
-                return;
-            }
-
-            Object.keys(styles).forEach((key) => {
-                element.style[key] = styles[key];
-            });
+        getNSAttributesForElement(element, attribute) {
+            return element.getAttributeNS(null, attribute);
         },
         getImageWrapper(item) {
-            const id = `${ID_PREFIX}${item.time}`;
+            const id = `id-${item.time}`;
 
-            return this.$el.querySelector(`.c-imagery-tsv__contents div[id=${id}]`);
+            return this.$el.querySelector(`.c-imagery-tsv__contents g[id=${id}]`);
         },
-        plotImagery(item, showImagePlaceholders, containerElement, index) {
+        plotImagery(item, showImagePlaceholders, svgElement, index) {
+            //TODO: Placeholder image
             let existingImageWrapper = this.getImageWrapper(item);
-            //imageWrapper wraps the vertical tick and the image
+            //imageWrapper wraps the vertical tick rect and the image
             if (existingImageWrapper) {
                 this.updateExistingImageWrapper(existingImageWrapper, item, showImagePlaceholders);
             } else {
-                let imageWrapper = this.createImageWrapper(index, item, showImagePlaceholders);
-                containerElement.appendChild(imageWrapper);
-            }
-        },
-        setImageDisplay(imageElement, showImagePlaceholders) {
-            if (showImagePlaceholders) {
-                imageElement.style.display = 'none';
-            } else {
-                imageElement.style.display = 'block';
+                let imageWrapper = this.createImageWrapper(index, item, showImagePlaceholders, svgElement);
+                svgElement.appendChild(imageWrapper);
             }
         },
         updateExistingImageWrapper(existingImageWrapper, item, showImagePlaceholders) {
-            //Update the x co-ordinates of the image wrapper and the url of image
+            //Update the x co-ordinates of the handle and image elements and the url of image
             //this is to avoid tearing down all elements completely and re-drawing them
             this.setNSAttributesForElement(existingImageWrapper, {
-                'data-show-image-placeholders': showImagePlaceholders
+                showImagePlaceholders
+            });
+            let imageTickElement = existingImageWrapper.querySelector('rect.c-imagery-tsv__image-handle');
+            this.setNSAttributesForElement(imageTickElement, {
+                x: this.xScale(item.time)
             });
-            existingImageWrapper.style.left = `${this.xScale(item.time)}px`;
 
-            let imageElement = existingImageWrapper.querySelector('img');
-            this.setNSAttributesForElement(imageElement, {
-                src: item.url
+            let imageRect = existingImageWrapper.querySelector('rect.c-imagery-tsv__image-placeholder');
+            this.setNSAttributesForElement(imageRect, {
+                x: this.xScale(item.time) + 2
+            });
+
+            let imageElement = existingImageWrapper.querySelector('image');
+            const selector = `href*=${existingImageWrapper.id}`;
+            let hoverEl = this.$el.querySelector(`.c-imagery-tsv__contents use[${selector}]`);
+            const hideImageUrl = (showImagePlaceholders && !hoverEl);
+            this.setNSAttributesForElement(imageElement, {
+                x: this.xScale(item.time) + 2,
+                url: hideImageUrl ? '' : item.url
             });
-            this.setImageDisplay(imageElement, showImagePlaceholders);
         },
-        createImageWrapper(index, item, showImagePlaceholders) {
-            const id = `${ID_PREFIX}${item.time}`;
-            let imageWrapper = document.createElement('div');
-            imageWrapper.classList.add(IMAGE_WRAPPER_CLASS);
-            imageWrapper.style.left = `${this.xScale(item.time)}px`;
+        createImageWrapper(index, item, showImagePlaceholders, svgElement) {
+            const id = `id-${item.time}`;
+            const imgSize = String(ROW_HEIGHT - 15);
+            let imageWrapper = document.createElementNS('http://www.w3.org/2000/svg', 'g');
             this.setNSAttributesForElement(imageWrapper, {
                 id,
-                'data-show-image-placeholders': showImagePlaceholders
+                class: 'c-imagery-tsv__image-wrapper',
+                showImagePlaceholders
+            });
+            //create image tick indicator
+            let imageTickElement = document.createElementNS('http://www.w3.org/2000/svg', 'rect');
+            this.setNSAttributesForElement(imageTickElement, {
+                class: 'c-imagery-tsv__image-handle',
+                x: this.xScale(item.time),
+                y: 5,
+                rx: 0,
+                width: 2,
+                height: String(ROW_HEIGHT - 10)
             });
-            //create image vertical tick indicator
-            let imageTickElement = document.createElement('div');
-            imageTickElement.classList.add('c-imagery-tsv__image-handle');
-            imageTickElement.style.width = '2px';
-            imageTickElement.style.height = `${String(ROW_HEIGHT - 10)}px`;
             imageWrapper.appendChild(imageTickElement);
 
-            //create placeholder - this will also hold the actual image
-            let imagePlaceholder = document.createElement('div');
-            imagePlaceholder.classList.add('c-imagery-tsv__image-placeholder');
-            imagePlaceholder.style.width = `${IMAGE_SIZE}px`;
-            imagePlaceholder.style.height = `${IMAGE_SIZE}px`;
-            imageWrapper.appendChild(imagePlaceholder);
-
-            //create image element
-            let imageElement = document.createElement('img');
-            this.setNSAttributesForElement(imageElement, {
-                src: item.url
+            let imageRect = document.createElementNS('http://www.w3.org/2000/svg', 'rect');
+            this.setNSAttributesForElement(imageRect, {
+                class: 'c-imagery-tsv__image-placeholder',
+                x: this.xScale(item.time) + 2,
+                y: 10,
+                rx: 0,
+                width: imgSize,
+                height: imgSize,
+                mask: `#image-${item.time}`
             });
-            imageElement.style.width = `${IMAGE_SIZE}px`;
-            imageElement.style.height = `${IMAGE_SIZE}px`;
-            this.setImageDisplay(imageElement, showImagePlaceholders);
+            imageWrapper.appendChild(imageRect);
 
-            //handle mousedown event to show the image in a large view
-            imageWrapper.addEventListener('mousedown', (e) => {
+            let imageElement = document.createElementNS('http://www.w3.org/2000/svg', 'image');
+            this.setNSAttributesForElement(imageElement, {
+                id: `image-${item.time}`,
+                x: this.xScale(item.time) + 2,
+                y: 10,
+                rx: 0,
+                width: imgSize,
+                height: imgSize,
+                url: showImagePlaceholders ? '' : item.url
+            });
+            imageWrapper.appendChild(imageElement);
+
+            //TODO: Don't add the hover listener if the width is too small
+            imageWrapper.addEventListener('mouseover', this.bringToForeground.bind(this, svgElement, imageWrapper, index, item.url));
+
+            return imageWrapper;
+        },
+        bringToForeground(svgElement, imageWrapper, index, url, event) {
+            const selector = `href*=${imageWrapper.id}`;
+            let hoverEls = this.$el.querySelectorAll(`.c-imagery-tsv__contents use:not([${selector}])`);
+            if (hoverEls.length > 0) {
+                this.removeFromForeground(hoverEls);
+            }
+
+            hoverEls = this.$el.querySelectorAll(`.c-imagery-tsv__contents use[${selector}]`);
+            if (hoverEls.length) {
+
+                return;
+            }
+
+            let imageElement = imageWrapper.querySelector('image');
+            this.setNSAttributesForElement(imageElement, {
+                url: url,
+                fill: 'none'
+            });
+            let hoverElement = document.createElementNS('http://www.w3.org/2000/svg', 'use');
+            this.setNSAttributesForElement(hoverElement, {
+                class: 'image-highlight',
+                x: 0,
+                href: `#${imageWrapper.id}`
+            });
+            this.setNSAttributesForElement(imageWrapper, {
+                class: 'c-imagery-tsv__image-wrapper is-hovered'
+            });
+            // We're using mousedown here and not 'click' because 'click' doesn't seem to be triggered reliably
+            hoverElement.addEventListener('mousedown', (e) => {
                 if (e.button === 0) {
                     this.expand(index);
                 }
             });
 
-            imagePlaceholder.appendChild(imageElement);
+            svgElement.appendChild(hoverElement);
 
-            return imageWrapper;
+        },
+        removeFromForeground(items) {
+            let hoverEls;
+            if (items) {
+                hoverEls = items;
+            } else {
+                hoverEls = this.$el.querySelectorAll(".c-imagery-tsv__contents use");
+            }
+
+            hoverEls.forEach(item => {
+                let selector = `id*=${this.getNSAttributesForElement(item, 'href').replace('#', '')}`;
+                let imageWrapper = this.$el.querySelector(`.c-imagery-tsv__contents g[${selector}]`);
+                this.setNSAttributesForElement(imageWrapper, {
+                    class: 'c-imagery-tsv__image-wrapper'
+                });
+                let showImagePlaceholders = this.getNSAttributesForElement(imageWrapper, 'showImagePlaceholders');
+                if (showImagePlaceholders === 'true') {
+                    let imageElement = imageWrapper.querySelector('image');
+                    this.setNSAttributesForElement(imageElement, {
+                        url: ''
+                    });
+                }
+
+                item.remove();
+            });
         }
     }
 };

src/plugins/imagery/components/ImageryView.vue

@@ -57,7 +57,7 @@
         </div>
         <div ref="imageBG"
              class="c-imagery__main-image__bg"
-             :class="{'paused unnsynced': isPaused && !isFixed,'stale':false }"
+             :class="{'paused unnsynced': isPaused,'stale':false }"
              @click="expand"
         >
             <div class="image-wrapper"
@@ -84,18 +84,18 @@
                 />
             </div>
         </div>
-
-        <button class="c-local-controls c-local-controls--show-on-hover c-imagery__prev-next-button c-nav c-nav--prev"
-                title="Previous image"
-                :disabled="isPrevDisabled"
-                @click="prevImage()"
-        ></button>
-
-        <button class="c-local-controls c-local-controls--show-on-hover c-imagery__prev-next-button c-nav c-nav--next"
-                title="Next image"
-                :disabled="isNextDisabled"
-                @click="nextImage()"
-        ></button>
+        <div class="c-local-controls c-local-controls--show-on-hover c-imagery__prev-next-buttons">
+            <button class="c-nav c-nav--prev"
+                    title="Previous image"
+                    :disabled="isPrevDisabled"
+                    @click="prevImage()"
+            ></button>
+            <button class="c-nav c-nav--next"
+                    title="Next image"
+                    :disabled="isNextDisabled"
+                    @click="nextImage()"
+            ></button>
+        </div>
 
         <div class="c-imagery__control-bar">
             <div class="c-imagery__time">
@@ -122,7 +122,6 @@
             </div>
             <div class="h-local-controls">
                 <button
-                    v-if="!isFixed"
                     class="c-button icon-pause pause-play"
                     :class="{'is-paused': isPaused}"
                     @click="paused(!isPaused, 'button')"
@@ -132,7 +131,7 @@
     </div>
     <div class="c-imagery__thumbs-wrapper"
          :class="[
-             { 'is-paused': isPaused && !isFixed },
+             { 'is-paused': isPaused },
              { 'is-autoscroll-off': !resizingWindow && !autoScroll && !isPaused }
          ]"
     >
@@ -200,14 +199,6 @@ export default {
     },
     mixins: [imageryData],
     inject: ['openmct', 'domainObject', 'objectPath', 'currentView'],
-    props: {
-        indexForFocusedImage: {
-            type: Number,
-            default() {
-                return undefined;
-            }
-        }
-    },
     data() {
         let timeSystem = this.openmct.time.timeSystem();
         this.metadata = {};
@@ -235,8 +226,7 @@ export default {
             imageContainerWidth: undefined,
             imageContainerHeight: undefined,
             lockCompass: true,
-            resizingWindow: false,
-            timeContext: undefined
+            resizingWindow: false
         };
     },
     computed: {
@@ -268,14 +258,7 @@ export default {
             return age < cutoff && !this.refreshCSS;
         },
         canTrackDuration() {
-            let hasClock;
-            if (this.timeContext) {
-                hasClock = this.timeContext.clock();
-            } else {
-                hasClock = this.openmct.time.clock();
-            }
-
-            return hasClock && this.timeSystem.isUTCBased;
+            return this.openmct.time.clock() && this.timeSystem.isUTCBased;
         },
         isNextDisabled() {
             let disabled = false;
@@ -396,28 +379,11 @@ export default {
             }
 
             return sizedImageDimensions;
-        },
-        isFixed() {
-            let clock;
-            if (this.timeContext) {
-                clock = this.timeContext.clock();
-            } else {
-                clock = this.openmct.time.clock();
-            }
-
-            return clock === undefined;
         }
     },
     watch: {
         imageHistorySize(newSize, oldSize) {
-            let imageIndex;
-            if (this.indexForFocusedImage !== undefined) {
-                imageIndex = this.initFocusedImageIndex;
-            } else {
-                imageIndex = newSize - 1;
-            }
-
-            this.setFocusedImage(imageIndex, false);
+            this.setFocusedImage(newSize - 1, false);
             this.scrollToRight();
         },
         focusedImageIndex() {
@@ -428,14 +394,9 @@ export default {
         }
     },
     async mounted() {
-        //We only need to use this till the user focuses an image manually
-        if (this.indexForFocusedImage !== undefined) {
-            this.initFocusedImageIndex = this.indexForFocusedImage;
-            this.isPaused = true;
-        }
-
-        this.setTimeContext = this.setTimeContext.bind(this);
-        this.setTimeContext();
+        //listen
+        this.openmct.time.on('timeSystem', this.trackDuration);
+        this.openmct.time.on('clock', this.trackDuration);
 
         // related telemetry keys
         this.spacecraftPositionKeys = ['positionX', 'positionY', 'positionZ'];
@@ -471,7 +432,8 @@ export default {
 
     },
     beforeDestroy() {
-        this.stopFollowingTimeContext();
+        this.openmct.time.off('timeSystem', this.trackDuration);
+        this.openmct.time.off('clock', this.trackDuration);
 
         if (this.thumbWrapperResizeObserver) {
             this.thumbWrapperResizeObserver.disconnect();
@@ -495,21 +457,6 @@ export default {
         }
     },
     methods: {
-        setTimeContext() {
-            this.stopFollowingTimeContext();
-            this.timeContext = this.openmct.time.getContextForView(this.objectPath);
-            //listen
-            this.timeContext.on('timeSystem', this.trackDuration);
-            this.timeContext.on('clock', this.trackDuration);
-            this.timeContext.on("timeContext", this.setTimeContext);
-        },
-        stopFollowingTimeContext() {
-            if (this.timeContext) {
-                this.timeContext.off("timeSystem", this.trackDuration);
-                this.timeContext.off("clock", this.trackDuration);
-                this.timeContext.off("timeContext", this.setTimeContext);
-            }
-        },
         expand() {
             const actionCollection = this.openmct.actions.getActionsCollection(this.objectPath, this.currentView);
             const visibleActions = actionCollection.getVisibleActions();
@@ -671,12 +618,7 @@ export default {
             });
         },
         setFocusedImage(index, thumbnailClick = false) {
-            if (thumbnailClick) {
-                //We use the props till the user changes what they want to see
-                this.initFocusedImageIndex = undefined;
-            }
-
-            if (this.isPaused && !thumbnailClick && this.initFocusedImageIndex === undefined) {
+            if (this.isPaused && !thumbnailClick) {
                 this.nextImageIndex = index;
                 //this could happen if bounds changes
                 if (this.focusedImageIndex > this.imageHistory.length - 1) {
@@ -707,12 +649,8 @@ export default {
             window.clearInterval(this.durationTracker);
         },
         updateDuration() {
-            let currentTime = this.timeContext.clock() && this.timeContext.clock().currentValue();
-            if (currentTime === undefined) {
-                this.numericDuration = currentTime;
-            } else {
-                this.numericDuration = currentTime - this.parsedSelectedTime;
-            }
+            let currentTime = this.openmct.time.clock() && this.openmct.time.clock().currentValue();
+            this.numericDuration = currentTime - this.parsedSelectedTime;
         },
         resetAgeCSS() {
             this.refreshCSS = true;

src/plugins/imagery/components/imagery-view.scss

@@ -285,17 +285,17 @@
     }
 }
 
-.c-imagery__prev-next-button {
-    pointer-events: all;
+.c-imagery__prev-next-buttons {
+    display: flex;
+    width: 100%;
+    justify-content: space-between;
+    pointer-events: none;
     position: absolute;
     top: 50%;
-    transform: translateY(-75%); // 75% due to transform: rotation approach to the button
+    transform: translateY(-75%);
 
-    &.c-nav {
-        position: absolute;
-
-        &--prev { left: 0; }
-        &--next { right: 0; }
+    .c-nav {
+        pointer-events: all;
     }
 
     .s-status-taking-snapshot & {
@@ -315,31 +315,13 @@
 
 /*************************************** IMAGERY IN TIMESTRIP VIEWS */
 .c-imagery-tsv {
-    div.c-imagery-tsv__image-wrapper {
+    g.c-imagery-tsv__image-wrapper {
         cursor: pointer;
-        position: absolute;
-        top: 0;
-        display: flex;
-        z-index: 1;
-        margin-top: 5px;
-
-        img {
-            align-self: flex-end;
-        }
-        &:hover {
-            z-index: 2;
 
+        &.is-hovered {
             filter: brightness(1) contrast(1) !important;
             [class*='__image-handle'] {
-                background-color: $colorBodyFg;
-            }
-
-            //[class*='__image-placeholder'] {
-            //    display: none;
-            //}
-
-            img {
-                display: block !important;
+                fill: $colorBodyFg;
             }
         }
     }
@@ -349,16 +331,14 @@
     }
 
     &__image-handle {
-        background-color: rgba($colorBodyFg, 0.5);
+        fill: rgba($colorBodyFg, 0.5);
     }
 
     &__image-placeholder {
-        background-color: pushBack($colorBodyBg, 0.3);
-        display: block;
-        align-self: flex-end;
+        fill: pushBack($colorBodyBg, 0.3);
     }
 
-    &:hover div.c-imagery-tsv__image-wrapper {
+    &:hover g.c-imagery-tsv__image-wrapper {
         // TODO CH: convert to theme constants
         filter: brightness(0.5) contrast(0.7);
     }

src/plugins/imagery/mixins/imageryData.js

@@ -26,10 +26,8 @@ export default {
     inject: ['openmct', 'domainObject', 'objectPath'],
     mounted() {
         // listen
-        this.boundsChange = this.boundsChange.bind(this);
-        this.timeSystemChange = this.timeSystemChange.bind(this);
-        this.setDataTimeContext = this.setDataTimeContext.bind(this);
-        this.setDataTimeContext();
+        this.openmct.time.on('bounds', this.boundsChange);
+        this.openmct.time.on('timeSystem', this.timeSystemChange);
 
         // set
         this.keyString = this.openmct.objects.makeKeyString(this.domainObject.identifier);
@@ -53,24 +51,10 @@ export default {
             delete this.unsubscribe;
         }
 
-        this.stopFollowingDataTimeContext();
+        this.openmct.time.off('bounds', this.boundsChange);
+        this.openmct.time.off('timeSystem', this.timeSystemChange);
     },
     methods: {
-        setDataTimeContext() {
-            this.stopFollowingDataTimeContext();
-            this.timeContext = this.openmct.time.getContextForView(this.objectPath);
-            this.timeContext.on('bounds', this.boundsChange);
-            this.boundsChange(this.timeContext.bounds());
-            this.timeContext.on('timeSystem', this.timeSystemChange);
-            this.timeContext.on("timeContext", this.setDataTimeContext);
-        },
-        stopFollowingDataTimeContext() {
-            if (this.timeContext) {
-                this.timeContext.off('bounds', this.boundsChange);
-                this.timeContext.off('timeSystem', this.timeSystemChange);
-                this.timeContext.off("timeContext", this.setDataTimeContext);
-            }
-        },
         datumIsNotValid(datum) {
             if (this.imageHistory.length === 0) {
                 return false;
@@ -127,7 +111,7 @@ export default {
             }
         },
         async requestHistory() {
-            let bounds = this.timeContext.bounds();
+            let bounds = this.openmct.time.bounds();
             this.requestCount++;
             const requestId = this.requestCount;
             this.imageHistory = [];
@@ -148,7 +132,7 @@ export default {
             }
         },
         timeSystemChange() {
-            this.timeSystem = this.timeContext.timeSystem();
+            this.timeSystem = this.openmct.time.timeSystem();
             this.timeKey = this.timeSystem.key;
             this.timeFormatter = this.getFormatter(this.timeKey);
             this.durationFormatter = this.getFormatter(this.timeSystem.durationFormat || DEFAULT_DURATION_FORMATTER);
@@ -157,7 +141,7 @@ export default {
             this.unsubscribe = this.openmct.telemetry
                 .subscribe(this.domainObject, (datum) => {
                     let parsedTimestamp = this.parseTime(datum);
-                    let bounds = this.timeContext.bounds();
+                    let bounds = this.openmct.time.bounds();
 
                     if (parsedTimestamp >= bounds.start && parsedTimestamp <= bounds.end) {
                         let image = this.normalizeDatum(datum);

src/plugins/imagery/pluginSpec.js

@@ -22,7 +22,6 @@
 
 import Vue from 'vue';
 import {
-    createMouseEvent,
     createOpenMct,
     resetApplicationState,
     simulateKeyEvent
@@ -33,6 +32,19 @@ 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;
+// const TOLERANCE = 0.50;
+
+// function comparisonFunction(valueOne, valueTwo) {
+//     let larger = valueOne;
+//     let smaller = valueTwo;
+//
+//     if (larger < smaller) {
+//         larger = valueTwo;
+//         smaller = valueOne;
+//     }
+//
+//     return (larger - smaller) < TOLERANCE;
+// }
 
 function getImageInfo(doc) {
     let imageElement = doc.querySelectorAll(MAIN_IMAGE_CLASS)[0];
@@ -78,13 +90,11 @@ describe("The Imagery View Layouts", () => {
     const START = Date.now();
     const COUNT = 10;
 
-    // let resolveFunction;
+    let resolveFunction;
     let originalRouterPath;
-    let telemetryPromise;
-    let telemetryPromiseResolve;
-    let cleanupFirst;
 
     let openmct;
+    let appHolder;
     let parent;
     let child;
     let imageTelemetry = generateTelemetry(START - TEN_MINUTES, COUNT);
@@ -188,63 +198,44 @@ describe("The Imagery View Layouts", () => {
 
     // this setups up the app
     beforeEach((done) => {
-        cleanupFirst = [];
+        appHolder = document.createElement('div');
+        appHolder.style.width = '640px';
+        appHolder.style.height = '480px';
 
         openmct = createOpenMct();
-        openmct.time.timeSystem('utc', {
-            start: START - (5 * ONE_MINUTE),
-            end: START + (5 * ONE_MINUTE)
-        });
 
-        telemetryPromise = new Promise((resolve) => {
-            telemetryPromiseResolve = resolve;
-        });
-
-        spyOn(openmct.telemetry, 'request').and.callFake(() => {
-            telemetryPromiseResolve(imageTelemetry);
-
-            return telemetryPromise;
-        });
+        openmct.install(openmct.plugins.MyItems());
+        openmct.install(openmct.plugins.LocalTimeSystem());
+        openmct.install(openmct.plugins.UTCTimeSystem());
 
         parent = document.createElement('div');
-        parent.style.width = '640px';
-        parent.style.height = '480px';
-
         child = document.createElement('div');
-        child.style.width = '640px';
-        child.style.height = '480px';
-
         parent.appendChild(child);
-        document.body.appendChild(parent);
+
+        // document.querySelector('body').append(parent);
 
         spyOn(window, 'ResizeObserver').and.returnValue({
             observe() {},
             disconnect() {}
         });
 
-        //spyOn(openmct.telemetry, 'request').and.returnValue(Promise.resolve([]));
-        spyOn(openmct.objects, 'get').and.returnValue(Promise.resolve(imageryObject));
+        spyOn(openmct.telemetry, 'request').and.returnValue(Promise.resolve([]));
+        spyOn(openmct.objects, 'get').and.returnValue(Promise.resolve({}));
 
         originalRouterPath = openmct.router.path;
 
         openmct.on('start', done);
-        openmct.startHeadless();
+        openmct.start(appHolder);
     });
 
-    afterEach((done) => {
+    afterEach(() => {
+        openmct.time.timeSystem('utc', {
+            start: 0,
+            end: 1
+        });
         openmct.router.path = originalRouterPath;
 
-        // Needs to be in a timeout because plots use a bunch of setTimeouts, some of which can resolve during or after
-        // teardown, which causes problems
-        // This is hacky, we should find a better approach here.
-        setTimeout(() => {
-            //Cleanup code that needs to happen before dom elements start being destroyed
-            cleanupFirst.forEach(cleanup => cleanup());
-            cleanupFirst = [];
-            document.body.removeChild(parent);
-
-            resetApplicationState(openmct).then(done).catch(done);
-        });
+        return resetApplicationState(openmct);
     });
 
     it("should provide an imagery time strip view when in a time strip", () => {
@@ -271,7 +262,7 @@ describe("The Imagery View Layouts", () => {
     });
 
     it("should provide an imagery view only for imagery producing objects", () => {
-        let applicableViews = openmct.objectViews.get(imageryObject, [imageryObject]);
+        let applicableViews = openmct.objectViews.get(imageryObject, []);
         let imageryView = applicableViews.find(
             viewProvider => viewProvider.key === imageryKey
         );
@@ -324,53 +315,51 @@ describe("The Imagery View Layouts", () => {
         let imageryViewProvider;
         let imageryView;
 
-        beforeEach(() => {
+        beforeEach(async () => {
+            let telemetryRequestResolve;
+            let telemetryRequestPromise = new Promise((resolve) => {
+                telemetryRequestResolve = resolve;
+            });
 
-            applicableViews = openmct.objectViews.get(imageryObject, [imageryObject]);
+            openmct.telemetry.request.and.callFake(() => {
+                telemetryRequestResolve(imageTelemetry);
+
+                return telemetryRequestPromise;
+            });
+
+            applicableViews = openmct.objectViews.get(imageryObject, []);
             imageryViewProvider = applicableViews.find(viewProvider => viewProvider.key === imageryKey);
-            imageryView = imageryViewProvider.view(imageryObject, [imageryObject]);
+            imageryView = imageryViewProvider.view(imageryObject);
             imageryView.show(child);
 
-            return Vue.nextTick();
+            await telemetryRequestPromise;
         });
 
-        // afterEach(() => {
-        //     openmct.time.stopClock();
-        //     openmct.router.removeListener('change:hash', resolveFunction);
-        //
-        //     imageryView.destroy();
-        // });
+        afterEach(() => {
+            openmct.time.stopClock();
+            openmct.router.removeListener('change:hash', resolveFunction);
 
-        it("on mount should show the the most recent image", (done) => {
-            //Looks like we need Vue.nextTick here so that computed properties settle down
+            imageryView.destroy();
+        });
+
+        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);
+        });
+
+        xit("should show the clicked thumbnail as the main image", (done) => {
+            const target = imageTelemetry[5].url;
+            parent.querySelectorAll(`img[src='${target}']`)[0].click();
             Vue.nextTick(() => {
                 const imageInfo = getImageInfo(parent);
 
-                expect(imageInfo.url.indexOf(imageTelemetry[COUNT - 1].timeId)).not.toEqual(-1);
+                expect(imageInfo.url.indexOf(imageTelemetry[5].timeId)).not.toEqual(-1);
                 done();
             });
         });
 
-        it("should show the clicked thumbnail as the main image", (done) => {
-            //Looks like we need Vue.nextTick here so that computed properties settle down
-            Vue.nextTick(() => {
-                const target = imageTelemetry[5].url;
-                parent.querySelectorAll(`img[src='${target}']`)[0].click();
-                Vue.nextTick(() => {
-                    const imageInfo = getImageInfo(parent);
-
-                    expect(imageInfo.url.indexOf(imageTelemetry[5].timeId)).not.toEqual(-1);
-                    done();
-                });
-            });
-        });
-
         xit("should show that an image is new", (done) => {
-            openmct.time.clock('local', {
-                start: -1000,
-                end: 1000
-            });
-
             Vue.nextTick(() => {
                 // used in code, need to wait to the 500ms here too
                 setTimeout(() => {
@@ -381,162 +370,84 @@ describe("The Imagery View Layouts", () => {
             });
         });
 
-        it("should show that an image is not new", (done) => {
-            Vue.nextTick(() => {
-                const target = imageTelemetry[2].url;
-                parent.querySelectorAll(`img[src='${target}']`)[0].click();
+        xit("should show that an image is not new", (done) => {
+            const target = imageTelemetry[2].url;
+            parent.querySelectorAll(`img[src='${target}']`)[0].click();
 
-                Vue.nextTick(() => {
+            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", (done) => {
+        xit("should navigate via arrow keys", (done) => {
+            let keyOpts = {
+                element: parent.querySelector('.c-imagery'),
+                key: 'ArrowLeft',
+                keyCode: 37,
+                type: 'keyup'
+            };
+
+            simulateKeyEvent(keyOpts);
+
             Vue.nextTick(() => {
-                let keyOpts = {
-                    element: parent.querySelector('.c-imagery'),
-                    key: 'ArrowLeft',
-                    keyCode: 37,
-                    type: 'keyup'
-                };
+                const imageInfo = getImageInfo(parent);
 
-                simulateKeyEvent(keyOpts);
-
-                Vue.nextTick(() => {
-                    const imageInfo = getImageInfo(parent);
-
-                    expect(imageInfo.url.indexOf(imageTelemetry[COUNT - 2].timeId)).not.toEqual(-1);
-                    done();
-                });
-            });
-        });
-
-        it("should navigate via numerous arrow keys", (done) => {
-            Vue.nextTick(() => {
-                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);
-
-                Vue.nextTick(() => {
-                    const imageInfo = getImageInfo(parent);
-
-                    expect(imageInfo.url.indexOf(imageTelemetry[COUNT - 3].timeId)).not.toEqual(-1);
-                    done();
-                });
-            });
-        });
-        it ('shows an auto scroll button when scroll to left', (done) => {
-            Vue.nextTick(() => {
-                // to mock what a scroll would do
-                imageryView._getInstance().$refs.ImageryContainer.autoScroll = false;
-                Vue.nextTick(() => {
-                    let autoScrollButton = parent.querySelector('.c-imagery__auto-scroll-resume-button');
-                    expect(autoScrollButton).toBeTruthy();
-                    done();
-                });
-            });
-        });
-        it ('scrollToRight is called when clicking on auto scroll button', (done) => {
-            Vue.nextTick(() => {
-                // use spyon to spy the scroll function
-                spyOn(imageryView._getInstance().$refs.ImageryContainer, 'scrollToRight');
-                imageryView._getInstance().$refs.ImageryContainer.autoScroll = false;
-                Vue.nextTick(() => {
-                    parent.querySelector('.c-imagery__auto-scroll-resume-button').click();
-                    expect(imageryView._getInstance().$refs.ImageryContainer.scrollToRight).toHaveBeenCalledWith('reset');
-                    done();
-                });
-            });
-        });
-    });
-
-    describe("imagery time strip view", () => {
-        let applicableViews;
-        let imageryViewProvider;
-        let imageryView;
-        let componentView;
-
-        beforeEach(() => {
-            openmct.time.timeSystem('utc', {
-                start: START - (5 * ONE_MINUTE),
-                end: START + (5 * ONE_MINUTE)
-            });
-
-            openmct.router.path = [{
-                identifier: {
-                    key: 'test-timestrip',
-                    namespace: ''
-                },
-                type: 'time-strip'
-            }];
-
-            applicableViews = openmct.objectViews.get(imageryObject, [imageryObject, {
-                identifier: {
-                    key: 'test-timestrip',
-                    namespace: ''
-                },
-                type: 'time-strip'
-            }]);
-            imageryViewProvider = applicableViews.find(viewProvider => viewProvider.key === imageryForTimeStripKey);
-            imageryView = imageryViewProvider.view(imageryObject, [imageryObject, {
-                identifier: {
-                    key: 'test-timestrip',
-                    namespace: ''
-                },
-                type: 'time-strip'
-            }]);
-            imageryView.show(child);
-
-            componentView = imageryView.getComponent().$children[0];
-            spyOn(componentView.previewAction, 'invoke').and.callThrough();
-
-            return Vue.nextTick();
-        });
-
-        it("on mount should show imagery within the given bounds", (done) => {
-            Vue.nextTick(() => {
-                const imageElements = parent.querySelectorAll('.c-imagery-tsv__image-wrapper');
-                expect(imageElements.length).toEqual(6);
+                expect(imageInfo.url.indexOf(imageTelemetry[COUNT - 2].timeId)).not.toEqual(-1);
                 done();
             });
         });
 
-        it("should show the clicked thumbnail as the preview image", (done) => {
-            Vue.nextTick(() => {
-                const mouseDownEvent = createMouseEvent("mousedown");
-                let imageWrapper = parent.querySelectorAll(`.c-imagery-tsv__image-wrapper`);
-                imageWrapper[2].dispatchEvent(mouseDownEvent);
+        it("should navigate via numerous arrow keys", (done) => {
+            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
+            };
 
-                Vue.nextTick(() => {
-                    expect(componentView.previewAction.invoke).toHaveBeenCalledWith([componentView.objectPath[0]], {
-                        indexForFocusedImage: 2,
-                        objectPath: componentView.objectPath
-                    });
-                    done();
-                });
+            // left thrice
+            simulateKeyEvent(leftKeyOpts);
+            simulateKeyEvent(leftKeyOpts);
+            simulateKeyEvent(leftKeyOpts);
+            // right once
+            simulateKeyEvent(rightKeyOpts);
+
+            Vue.nextTick(() => {
+                const imageInfo = getImageInfo(parent);
+
+                expect(imageInfo.url.indexOf(imageTelemetry[COUNT - 3].timeId)).not.toEqual(-1);
+                done();
             });
         });
+        it ('shows an auto scroll button when scroll to left', async () => {
+            // to mock what a scroll would do
+            imageryView._getInstance().$refs.ImageryContainer.autoScroll = false;
+            await Vue.nextTick();
+            let autoScrollButton = parent.querySelector('.c-imagery__auto-scroll-resume-button');
+            expect(autoScrollButton).toBeTruthy();
+        });
+        it ('scrollToRight is called when clicking on auto scroll button', async () => {
+            // use spyon to spy the scroll function
+            spyOn(imageryView._getInstance().$refs.ImageryContainer, 'scrollToRight');
+            imageryView._getInstance().$refs.ImageryContainer.autoScroll = false;
+            await Vue.nextTick();
+            parent.querySelector('.c-imagery__auto-scroll-resume-button').click();
+            expect(imageryView._getInstance().$refs.ImageryContainer.scrollToRight).toHaveBeenCalledWith('reset');
+
+        });
     });
 });

src/plugins/licenses/Licenses.vue

@@ -45,7 +45,8 @@
     </div>
 </div>
 </template>
-
+<style lang="sass">
+</style>
 <script>
 import packages from './third-party-licenses.json';
 

src/plugins/notebook/components/NotebookEmbed.vue

@@ -180,13 +180,9 @@ export default {
                 this.openmct.notifications.alert(message);
             }
 
-            if (this.openmct.editor.isEditing()) {
-                this.previewEmbed();
-            } else {
-                const relativeHash = hash.slice(hash.indexOf('#'));
-                const url = new URL(relativeHash, `${location.protocol}//${location.host}${location.pathname}`);
-                this.openmct.router.navigate(url.hash);
-            }
+            const relativeHash = hash.slice(hash.indexOf('#'));
+            const url = new URL(relativeHash, `${location.protocol}//${location.host}${location.pathname}`);
+            this.openmct.router.navigate(url.hash);
         },
         formatTime(unixTime, timeFormat) {
             return Moment.utc(unixTime).format(timeFormat);

src/plugins/notebook/plugin.js

@@ -115,8 +115,7 @@ export default function NotebookPlugin() {
         });
         const indicator = {
             element: notebookSnapshotIndicator.$mount().$el,
-            key: 'notebook-snapshot-indicator',
-            priority: openmct.priority.DEFAULT
+            key: 'notebook-snapshot-indicator'
         };
 
         openmct.indicators.add(indicator);

src/plugins/notebook/pluginSpec.js

@@ -148,14 +148,10 @@ describe("Notebook plugin:", () => {
                 'observe'
             ]);
 
-            openmct.editor = {};
-            openmct.editor.isEditing = () => false;
-
             const applicableViews = openmct.objectViews.get(notebookViewObject, [notebookViewObject]);
             notebookViewProvider = applicableViews.find(viewProvider => viewProvider.key === 'notebook-vue');
 
             testObjectProvider.get.and.returnValue(Promise.resolve(notebookViewObject));
-            testObjectProvider.create.and.returnValue(Promise.resolve(notebookViewObject));
             openmct.objects.addProvider('test-namespace', testObjectProvider);
             testObjectProvider.observe.and.returnValue(() => {});
             testObjectProvider.create.and.returnValue(Promise.resolve(true));

src/plugins/notebook/snapshot.js

@@ -110,7 +110,8 @@ export default class Snapshot {
         }
 
         return () => {
-            window.location.href = window.location.origin + url;
+            const path = window.location.href.split('#');
+            window.location.href = path[0] + url;
         };
     }
 }

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

@@ -44,7 +44,6 @@ const notebookDomainObject = {
         namespace: ''
     },
     type: 'notebook',
-    name: 'Test Notebook',
     configuration: {
         defaultSort: 'oldest',
         entries: notebookEntries,
@@ -119,12 +118,6 @@ describe('Notebook Entries:', () => {
             'create',
             'update'
         ]));
-        openmct.editor = {
-            isEditing: () => false
-        };
-        openmct.objects.isPersistable = () => true;
-        openmct.objects.save = () => Promise.resolve(true);
-
         window.localStorage.setItem('notebook-storage', null);
     });
 

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

@@ -96,9 +96,6 @@ export function setDefaultNotebookPageId(pageId) {
 
 export function validateNotebookStorageObject() {
     const notebookStorage = getDefaultNotebook();
-    if (!notebookStorage) {
-        return true;
-    }
 
     let valid = false;
     if (notebookStorage) {

src/plugins/notificationIndicator/plugin.js

@@ -36,8 +36,7 @@ export default function plugin() {
 
         let indicator = {
             key: 'notifications-indicator',
-            element: component.$mount().$el,
-            priority: openmct.priority.DEFAULT
+            element: component.$mount().$el
         };
 
         openmct.indicators.add(indicator);

src/plugins/performanceIndicator/pluginSpec.js

@@ -34,7 +34,7 @@ describe('the plugin', () => {
     let countFramesPromise;
 
     beforeEach((done) => {
-        openmct = createOpenMct();
+        openmct = createOpenMct(false);
 
         element = document.createElement('div');
         child = document.createElement('div');

src/plugins/persistence/couch/CouchChangesFeed.js

@@ -35,7 +35,6 @@
 
                 do {
                     await self.listenForChanges(event.data.url, event.data.body, port);
-                    // eslint-disable-next-line no-unmodified-loop-condition
                 } while (connected);
             }
         };

src/plugins/persistence/couch/README.md

@@ -1,48 +0,0 @@
-# Introduction
-These instructions are for setting up CouchDB for a **development** environment. For a production environment, we recommend running OpenMCT behind a proxy server (e.g., Nginx or Apache), and securing the CouchDB server properly:
-https://docs.couchdb.org/en/main/intro/security.html
-
-# Installing CouchDB
-## OSX
-1. Install CouchDB using: `brew install couchdb`
-2. Edit `/usr/local/etc/local.ini` and add and admin password:
-  ```
-  [admins]
-  admin = youradminpassword
-  ```
-  And set the server up for single node:
-  ```
-  [couchdb]
-  single_node=true
-  ```
-
-3. Start CouchDB by running: `couchdb`
-4. Add the `_global_changes` database using `curl` (note the `youradminpassword` should be changed to what you set above 👆): `curl -X PUT http://admin:youradminpassword@127.0.0.1:5984/_global_changes`
-## Other Operating Systems
-Follow the installation instructions from the CouchDB installation guide: https://docs.couchdb.org/en/stable/install/index.html
-
-# Configuring OpenMCT
-1. Navigate to http://localhost:5984/_utils
-2. Create a database called `openmct`
-3. In your OpenMCT directory, edit `openmct/index.html`, and comment out:
-```
-openmct.install(openmct.plugins.LocalStorage());
-```
-Add a line to install the CouchDB plugin for OpenMCT:
-```
-openmct.install(openmct.plugins.CouchDB("http://localhost:5984/openmct/"));
-```
-6. Enable cors in CouchDB by editing `/usr/local/etc/local.ini` and add: `
-```
-[chttpd]
-enable_cors = true
-
-[cors]
-origins = http://localhost:8080
-```
-7. Remove permission restrictions in CouchDB from OpenMCT by navigating to http://127.0.0.1:5984/_utils/#/database/openmct/permissions and deleting `_admin` roles for both `Admin` and `Member`.
-8. Start openmct by running `npm start` in the OpenMCT directory.
-9. Navigate to http://localhost:8080/ and create a random object in OpenMCT (e.g., a `Clock`) and save. You may get an error saying that the objects failed to persist. This is a known error that you can ignore, and will only happen the first time you save.
-10. Navigate to: http://127.0.0.1:5984/_utils/#database/openmct/_all_docs
-11. Look at the `JSON` tab and ensure you can see the `Clock` object you created above.
-12. All done! 🏆

src/plugins/persistence/couch/pluginSpec.js

@@ -49,7 +49,7 @@ describe('the plugin', () => {
             filter: {},
             disableObserve: true
         };
-        openmct = createOpenMct();
+        openmct = createOpenMct(false);
 
         openmct.$injector = jasmine.createSpyObj('$injector', ['get']);
         mockIdentifierService = jasmine.createSpyObj(

src/plugins/plan/PlanViewProvider.js

@@ -25,9 +25,7 @@ import Vue from 'vue';
 
 export default function PlanViewProvider(openmct) {
     function isCompactView(objectPath) {
-        let isChildOfTimeStrip = objectPath.find(object => object.type === 'time-strip');
-
-        return isChildOfTimeStrip && !openmct.router.isNavigatedObject(objectPath);
+        return objectPath.find(object => object.type === 'time-strip') !== undefined;
     }
 
     return {

src/plugins/plan/pluginSpec.js

@@ -30,22 +30,13 @@ describe('the plugin', function () {
     let child;
     let openmct;
     let appHolder;
-    let originalRouterPath;
 
     beforeEach((done) => {
         appHolder = document.createElement('div');
         appHolder.style.width = '640px';
         appHolder.style.height = '480px';
 
-        const timeSystemOptions = {
-            timeSystemKey: 'utc',
-            bounds: {
-                start: 1597160002854,
-                end: 1597181232854
-            }
-        };
-
-        openmct = createOpenMct(timeSystemOptions);
+        openmct = createOpenMct();
         openmct.install(new PlanPlugin());
 
         planDefinition = openmct.types.get('plan').definition;
@@ -58,15 +49,11 @@ describe('the plugin', function () {
         child.style.height = '480px';
         element.appendChild(child);
 
-        originalRouterPath = openmct.router.path;
-
         openmct.on('start', done);
         openmct.start(appHolder);
     });
 
     afterEach(() => {
-        openmct.router.path = originalRouterPath;
-
         return resetApplicationState(openmct);
     });
 
@@ -85,17 +72,18 @@ describe('the plugin', function () {
     });
 
     describe('the plan view', () => {
+
         it('provides a plan view', () => {
             const testViewObject = {
                 id: "test-object",
                 type: "plan"
             };
-            openmct.router.path = [testViewObject];
 
-            const applicableViews = openmct.objectViews.get(testViewObject, [testViewObject]);
+            const applicableViews = openmct.objectViews.get(testViewObject, []);
             let planView = applicableViews.find((viewProvider) => viewProvider.key === 'plan.view');
             expect(planView).toBeDefined();
         });
+
     });
 
     describe('the plan view displays activities', () => {
@@ -149,9 +137,7 @@ describe('the plugin', function () {
                 }
             };
 
-            openmct.router.path = [planDomainObject];
-
-            const applicableViews = openmct.objectViews.get(planDomainObject, [planDomainObject]);
+            const applicableViews = openmct.objectViews.get(planDomainObject, []);
             planView = applicableViews.find((viewProvider) => viewProvider.key === 'plan.view');
             let view = planView.view(planDomainObject, mockObjectPath);
             view.show(child, true);
@@ -169,22 +155,12 @@ describe('the plugin', function () {
             expect(labelEl.innerHTML).toEqual('TEST-GROUP');
         });
 
-        it('displays the activities and their labels', (done) => {
-            const bounds = {
-                start: 1597160002854,
-                end: 1597181232854
-            };
-
-            openmct.time.bounds(bounds);
-
-            Vue.nextTick(() => {
-                const rectEls = element.querySelectorAll('.c-plan__contents rect');
-                expect(rectEls.length).toEqual(2);
-                const textEls = element.querySelectorAll('.c-plan__contents text');
-                expect(textEls.length).toEqual(3);
-
-                done();
-            });
+        it('displays the activities and their labels', () => {
+            const rectEls = element.querySelectorAll('.c-plan__contents rect');
+            expect(rectEls.length).toEqual(2);
+            const textEls = element.querySelectorAll('.c-plan__contents text');
+            expect(textEls.length).toEqual(3);
         });
     });
+
 });

src/plugins/plot/ColorSwatch.vue

@@ -21,62 +21,72 @@
 -->
 <template>
 <div class="u-contents">
-    <div v-if="canEdit"
-         class="grid-row"
+    <ul v-if="canEdit"
+        class="l-inspector-part"
     >
-        <div class="grid-cell label"
-             :title="editTitle"
-        >{{ shortLabel }}</div>
-        <div class="grid-cell value">
-            <div class="c-click-swatch c-click-swatch--menu"
-                 @click="toggleSwatch()"
-            >
-                <span class="c-color-swatch"
-                      :style="{ background: currentColor }"
+        <h2 v-if="heading"
+            :title="heading"
+        >{{ heading }}</h2>
+        <li class="grid-row">
+            <div class="grid-cell label"
+                 :title="editTitle"
+            >{{ shortLabel }}</div>
+            <div class="grid-cell value">
+                <div class="c-click-swatch c-click-swatch--menu"
+                     @click="toggleSwatch()"
                 >
-                </span>
-            </div>
-            <div class="c-palette c-palette--color">
-                <div v-show="swatchActive"
-                     class="c-palette__items"
-                >
-                    <div v-for="group in colorPaletteGroups"
-                         :key="group.id"
-                         class="u-contents"
+                    <span class="c-color-swatch"
+                          :style="{ background: currentColor }"
                     >
-                        <div v-for="color in group"
-                             :key="color.id"
-                             class="c-palette__item"
-                             :class="{ 'selected': currentColor === color.hexString }"
-                             :style="{ background: color.hexString }"
-                             @click="setColor(color)"
+                    </span>
+                </div>
+                <div class="c-palette c-palette--color">
+                    <div v-show="swatchActive"
+                         class="c-palette__items"
+                    >
+                        <div v-for="group in colorPaletteGroups"
+                             :key="group.id"
+                             class="u-contents"
                         >
+                            <div v-for="color in group"
+                                 :key="color.id"
+                                 class="c-palette__item"
+                                 :class="{ 'selected': currentColor === color.hexString }"
+                                 :style="{ background: color.hexString }"
+                                 @click="setColor(color)"
+                            >
+                            </div>
                         </div>
                     </div>
                 </div>
             </div>
-        </div>
-    </div>
-    <div v-else
-         class="grid-row"
+        </li>
+    </ul>
+    <ul v-else
+        class="l-inspector-part"
     >
-        <div class="grid-cell label"
-             :title="viewTitle"
-        >{{ shortLabel }}</div>
-        <div class="grid-cell value">
-            <span class="c-color-swatch"
-                  :style="{
-                      'background': currentColor
-                  }"
-            >
-            </span>
-        </div>
-    </div>
+        <h2 v-if="heading"
+            :title="heading"
+        >{{ heading }}</h2>
+        <li class="grid-row">
+            <div class="grid-cell label"
+                 :title="viewTitle"
+            >{{ shortLabel }}</div>
+            <div class="grid-cell value">
+                <span class="c-color-swatch"
+                      :style="{
+                          'background': currentColor
+                      }"
+                >
+                </span>
+            </div>
+        </li>
+    </ul>
 </div>
 </template>
 
 <script>
-import ColorPalette from './ColorPalette';
+import ColorPalette from './lib/ColorPalette';
 
 export default {
     inject: ['openmct', 'domainObject'],
@@ -104,6 +114,12 @@ export default {
             default() {
                 return 'Color';
             }
+        },
+        heading: {
+            type: String,
+            default() {
+                return '';
+            }
         }
     },
     data() {