Merge branch 'master' into remove-unused-code

* Run full regression suite on PR
* rename job
* specify new testsuites to run
* use newer objects types
* Limit concurrency to 2 workers
* CI!
Co-authored-by: John Hill <john.c.hill@nasa.gov>
Co-authored-by: John Hill <jchill2.spam@gmail.com>

.circleci/config.yml

@@ -153,7 +153,7 @@ workflows:
           post-steps:
             - upload_code_covio               
       - e2e-test:
-          name: e2e-smoke
+          name: e2e-ci
           node-version: lts/fermium
           suite: ci
   the-nightly: #These jobs do not run on PRs, but against master at night

API.md

@@ -52,6 +52,8 @@
     - [The URL Status Indicator](#the-url-status-indicator)
     - [Creating a Simple Indicator](#creating-a-simple-indicator)
     - [Custom Indicators](#custom-indicators)
+  - [Priority API](#priority-api)
+    - [Priority Types](#priority-types)
 
 <!-- END doctoc generated TOC please keep comment here to allow auto update -->
 
@@ -247,16 +249,24 @@ To do so, use the `addRoot` method of the object API.
 eg.
 ```javascript
 openmct.objects.addRoot({
-        namespace: "example.namespace",
-        key: "my-key"
-    });
+    namespace: "example.namespace",
+    key: "my-key"
+},
+openmct.priority.HIGH);
 ```
 
-The `addRoot` function takes a single [object identifier](#domain-objects-and-identifiers) 
-as an argument. 
+The `addRoot` function takes a two arguments, the first can be an [object identifier](#domain-objects-and-identifiers) for a root level object, or an array of identifiers for root 
+level objects, or a function that returns a promise for an identifier or an array of root level objects, the second is a [priority](#priority-api) or numeric value.
 
-Root objects are loaded just like any other objects, i.e. via an object
-provider.
+When using the `getAll` method of the object API, they will be returned in order of priority.
+
+eg.
+```javascript
+openmct.objects.addRoot(identifier, openmct.priority.LOW); // low = -1000, will appear last in composition or tree
+openmct.objects.addRoot(otherIdentifier, openmct.priority.HIGH); // high = 1000, will appear first in composition or tree
+```
+
+Root objects are loaded just like any other objects, i.e. via an object provider.
 
 ## Object Providers
 
@@ -1051,3 +1061,25 @@ A completely custom indicator can be added by simply providing a DOM element to
         element: domNode
     });
 ```
+
+## Priority API
+
+Open MCT provides some built-in priority values that can be used in the application for view providers, indicators, root object order, and more.
+
+### Priority Types
+
+Currently, the Open MCT Priority API provides (type: numeric value):
+- HIGH: 1000
+- Default: 0
+- LOW: -1000
+
+View provider Example:
+
+``` javascript
+  class ViewProvider {
+    ...
+    priority() {
+        return openmct.priority.HIGH;
+    }
+}
+```

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) [![This project is using Percy.io for visual regression testing.](https://percy.io/static/images/percy-badge.svg)](https://percy.io/b2e34b17/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) [![codecov](https://codecov.io/gh/nasa/openmct/branch/master/graph/badge.svg?token=7DQIipp3ej)](https://codecov.io/gh/nasa/openmct) [![This project is using Percy.io for visual regression testing.](https://percy.io/static/images/percy-badge.svg)](https://percy.io/b2e34b17/openmct) [![npm version](https://img.shields.io/npm/v/openmct.svg)](https://www.npmjs.com/package/openmct) 
 
 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.
 

e2e/playwright-ci.config.js

@@ -13,6 +13,7 @@ const config = {
         timeout: 200 * 1000,
         reuseExistingServer: !process.env.CI
     },
+    workers: 2, //Limit to 2 for CircleCI Agent
     use: {
         browserName: "chromium",
         baseURL: 'http://localhost:8080/',

package.json

@@ -96,7 +96,7 @@
     "test:debug": "cross-env NODE_ENV=debug karma start --no-single-run",
     "test:coverage": "cross-env NODE_OPTIONS=\"--max_old_space_size=4096\" COVERAGE=true karma start --single-run",
     "test:coverage:firefox": "cross-env NODE_OPTIONS=\"--max_old_space_size=4096\" karma start --single-run --browsers=FirefoxHeadless",
-    "test:e2e:ci": "npx playwright test --config=e2e/playwright-ci.config.js smoke",
+    "test:e2e:ci": "npx playwright test --config=e2e/playwright-ci.config.js smoke default condition.e2e",
     "test:e2e:local": "npx playwright test --config=e2e/playwright-local.config.js",
     "test:e2e:visual": "percy exec -- npx playwright test --config=e2e/playwright-visual.config.js default",
     "test:e2e:full": "npx playwright test --config=e2e/playwright-ci.config.js",

platform/framework/src/FrameworkLayer.js

@@ -20,12 +20,18 @@
  * at runtime from the About dialog for additional information.
  *****************************************************************************/
 
+// TODO delete me!
+class ImplementationLoader {
+    load() {
+        return Promise.resolve({});
+    }
+}
+
 define([
     './Constants',
     './FrameworkInitializer',
     './LogLevel',
     './load/BundleLoader',
-    './resolve/ImplementationLoader',
     './resolve/ExtensionResolver',
     './resolve/BundleResolver',
     './register/CustomRegistrars',
@@ -37,7 +43,6 @@ define([
     FrameworkInitializer,
     LogLevel,
     BundleLoader,
-    ImplementationLoader,
     ExtensionResolver,
     BundleResolver,
     CustomRegistrars,
@@ -62,7 +67,7 @@ define([
             loader = new BundleLoader($http, $log, openmct.legacyRegistry),
             resolver = new BundleResolver(
                 new ExtensionResolver(
-                    new ImplementationLoader({}),
+                    new ImplementationLoader(),
                     $log
                 ),
                 $log

platform/framework/src/resolve/ImplementationLoader.js

@@ -1,64 +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.
- *****************************************************************************/
-
-/**
- * Module defining ImplementationLoader. Created by vwoeltje on 11/3/14.
- */
-define(
-    [],
-    function () {
-
-        /**
-         * Responsible for loading extension implementations
-         * (AMD modules.) Acts as a wrapper around RequireJS to
-         * provide a promise-like API.
-         * @memberof platform/framework
-         * @constructor
-         * @param {*} require RequireJS, or an object with similar API
-         * @param {*} $log Angular's logging service
-         */
-        function ImplementationLoader(require) {
-            this.require = require;
-        }
-
-        /**
-         * Load an extension's implementation; or, equivalently,
-         * load an AMD module. This is fundamentally similar
-         * to a call to RequireJS, except that the result is
-         * wrapped in a promise. The promise will be fulfilled
-         * with the loaded module, or rejected with the error
-         * reported by Require.
-         *
-         * @param {string} path the path to the module to load
-         * @returns {Promise} a promise for the specified module.
-         */
-        ImplementationLoader.prototype.load = function loadModule(path) {
-            var require = this.require;
-
-            return new Promise(function (fulfill, reject) {
-                require([path], fulfill, reject);
-            });
-        };
-
-        return ImplementationLoader;
-    }
-);

platform/framework/test/resolve/ImplementationLoaderSpec.js

@@ -1,88 +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.
- *****************************************************************************/
-
-/**
- * ImplementationLoaderSpec. Created by vwoeltje on 11/6/14.
- */
-define(
-    ["../../src/resolve/ImplementationLoader"],
-    function (ImplementationLoader) {
-
-        describe("The implementation loader", function () {
-            var required,
-                loader;
-
-            function mockRequire(names, fulfill, reject) {
-                required = {
-                    names: names,
-                    fulfill: fulfill,
-                    reject: reject
-                };
-            }
-
-            beforeEach(function () {
-                required = undefined;
-                loader = new ImplementationLoader(mockRequire);
-            });
-
-            it("passes script names to require", function () {
-                loader.load("xyz.js");
-                expect(required.names).toEqual(["xyz.js"]);
-            });
-
-            it("wraps require results in a Promise that can resolve", function () {
-                // Load and get the result
-                var promise = loader.load("xyz.js").then(function (result) {
-                    expect(result).toEqual("test result");
-                });
-
-                required.fulfill("test result");
-
-                return promise;
-            });
-
-            it("wraps require results in a Promise that can reject", function () {
-                var result,
-                    rejection;
-
-                // Load and get the result
-                var promise = loader.load("xyz.js").then(
-                    function (v) {
-                        result = v;
-                    },
-                    function (v) {
-                        rejection = v;
-                    });
-
-                expect(result).toBeUndefined();
-
-                required.reject("test result");
-
-                return promise.then(function () {
-                    expect(result).toBeUndefined();
-                    expect(rejection).toEqual("test result");
-                });
-            });
-
-        });
-    }
-);

src/api/objects/InMemorySearchProvider.js

@@ -1,5 +1,5 @@
 /*****************************************************************************
- * Open MCT, Copyright (c) 2014-2022, United States Government
+ * Open MCT, Copyright (c) 2014-2021, United States Government
  * as represented by the Administrator of the National Aeronautics and Space
  * Administration. All rights reserved.
  *
@@ -36,8 +36,8 @@ class InMemorySearchProvider {
          */
         this.MAX_CONCURRENT_REQUESTS = 100;
         /**
-         * If max results is not specified in query, use this as default.
-         */
+        * If max results is not specified in query, use this as default.
+        */
         this.DEFAULT_MAX_RESULTS = 100;
 
         this.openmct = openmct;
@@ -68,14 +68,6 @@ class InMemorySearchProvider {
                 this.worker.port.onmessageerror = null;
                 this.worker.port.close();
             }
-
-            Object.entries(this.indexedIds).forEach(([keyString, unobserve]) => {
-                if (typeof unobserve === 'function') {
-                    unobserve();
-                }
-
-                delete this.indexedIds[keyString];
-            });
         });
     }
 
@@ -145,7 +137,7 @@ class InMemorySearchProvider {
         };
         modelResults.hits = await Promise.all(event.data.results.map(async (hit) => {
             const identifier = this.openmct.objects.parseKeyString(hit.keyString);
-            const domainObject = await this.openmct.objects.get(identifier);
+            const domainObject = await this.openmct.objects.get(identifier.key);
 
             return domainObject;
         }));
@@ -223,27 +215,27 @@ class InMemorySearchProvider {
 
     onMutationOfIndexedObject(domainObject) {
         const provider = this;
-
-        provider.index(domainObject);
+        provider.index(domainObject.identifier, domainObject);
     }
 
     /**
-     * Pass a domainObject to the worker to be indexed.
-     * If the object has composition, schedule those ids for later indexing.
-     * Watch for object changes and re-index object and children if so
+     * Pass an id and model to the worker to be indexed.  If the model has
+     * composition, schedule those ids for later indexing.
      *
      * @private
-     * @param domainObject a domainObject
+     * @param id a model id
+     * @param model a model
      */
-    async index(domainObject) {
+    async index(id, domainObject) {
         const provider = this;
-        const keyString = this.openmct.objects.makeKeyString(domainObject.identifier);
-
+        const keyString = this.openmct.objects.makeKeyString(id);
         if (!this.indexedIds[keyString]) {
-            this.indexedIds[keyString] = this.openmct.objects.observe(domainObject, '*', this.onMutationOfIndexedObject);
+            this.openmct.objects.observe(domainObject, `*`, this.onMutationOfIndexedObject);
         }
 
-        if ((keyString !== 'ROOT')) {
+        this.indexedIds[keyString] = true;
+
+        if ((id.key !== 'ROOT')) {
             if (this.worker) {
                 this.worker.port.postMessage({
                     request: 'index',
@@ -255,12 +247,14 @@ class InMemorySearchProvider {
             }
         }
 
-        const composition = this.openmct.composition.get(domainObject);
+        const composition = this.openmct.composition.registry.find(foundComposition => {
+            return foundComposition.appliesTo(domainObject);
+        });
 
-        if (composition !== undefined) {
-            const children = await composition.load(domainObject);
-            children.forEach(function (child) {
-                provider.scheduleForIndexing(child.identifier);
+        if (composition) {
+            const childIdentifiers = await composition.load(domainObject);
+            childIdentifiers.forEach(function (childIdentifier) {
+                provider.scheduleForIndexing(childIdentifier);
             });
         }
     }
@@ -277,12 +271,12 @@ class InMemorySearchProvider {
         const provider = this;
 
         this.pendingRequests += 1;
-        const domainObject = await this.openmct.objects.get(keyString);
+        const identifier = await this.openmct.objects.parseKeyString(keyString);
+        const domainObject = await this.openmct.objects.get(identifier.key);
         delete provider.pendingIndex[keyString];
-
         try {
             if (domainObject) {
-                await provider.index(domainObject);
+                await provider.index(identifier, domainObject);
             }
         } catch (error) {
             console.warn('Failed to index domain object ' + keyString, error);
@@ -311,9 +305,9 @@ class InMemorySearchProvider {
     }
 
     /**
-     * A local version of the same SharedWorker function
-     * if we don't have SharedWorkers available (e.g., iOS)
-     */
+    * A local version of the same SharedWorker function
+    * if we don't have SharedWorkers available (e.g., iOS)
+    */
     localIndexItem(keyString, model) {
         this.localIndexedItems[keyString] = {
             type: model.type,

src/api/objects/InMemorySearchWorker.js

@@ -33,10 +33,8 @@
 
         port.onmessage = function (event) {
             if (event.data.request === 'index') {
-                console.log('onmessage index: ', event.data);
                 indexItem(event.data.keyString, event.data.model);
             } else if (event.data.request === 'search') {
-                console.log('onmessage search: ', event.data);
                 port.postMessage(search(event.data));
             }
         };
@@ -79,8 +77,6 @@
             queryId: data.queryId
         };
 
-        console.log('indexed on search: ', indexedItems);
-
         results = Object.values(indexedItems).filter((indexedItem) => {
             return indexedItem.name.toLowerCase().includes(input);
         });

src/api/objects/ObjectAPI.js

@@ -41,7 +41,7 @@ function ObjectAPI(typeRegistry, openmct) {
     this.typeRegistry = typeRegistry;
     this.eventEmitter = new EventEmitter();
     this.providers = {};
-    this.rootRegistry = new RootRegistry();
+    this.rootRegistry = new RootRegistry(openmct);
     this.inMemorySearchProvider = new InMemorySearchProvider(openmct);
 
     this.rootProvider = new RootObjectProvider(this.rootRegistry);
@@ -367,14 +367,17 @@ ObjectAPI.prototype.endTransaction = function () {
 
 /**
  * Add a root-level object.
- * @param {module:openmct.ObjectAPI~Identifier|function} an array of
- *        identifiers for root level objects, or a function that returns a
+ * @param {module:openmct.ObjectAPI~Identifier|array|function} identifier an identifier or
+ *        an array of identifiers for root level objects, or a function that returns a
  *        promise for an identifier or an array of root level objects.
+ * @param {module:openmct.PriorityAPI~priority|Number} priority a number representing
+ *        this item(s) position in the root object's composition (example: order in object tree).
+ *        For arrays, they are treated as blocks.
  * @method addRoot
  * @memberof module:openmct.ObjectAPI#
  */
-ObjectAPI.prototype.addRoot = function (key) {
-    this.rootRegistry.addRoot(key);
+ObjectAPI.prototype.addRoot = function (identifier, priority) {
+    this.rootRegistry.addRoot(identifier, priority);
 };
 
 /**

src/api/objects/RootRegistry.js

@@ -20,39 +20,43 @@
  * at runtime from the About dialog for additional information.
  *****************************************************************************/
 
-define([
-    'lodash'
-], function (
-    _
-) {
+import utils from './object-utils';
 
-    function RootRegistry() {
-        this.providers = [];
+export default class RootRegistry {
+
+    constructor(openmct) {
+        this._rootItems = [];
+        this._openmct = openmct;
     }
 
-    RootRegistry.prototype.getRoots = function () {
-        const promises = this.providers.map(function (provider) {
-            return provider();
-        });
+    getRoots() {
+        const sortedItems = this._rootItems.sort((a, b) => b.priority - a.priority);
+        const promises = sortedItems.map((rootItem) => rootItem.provider());
 
-        return Promise.all(promises)
-            .then(_.flatten);
-    };
-
-    function isKey(key) {
-        return _.isObject(key) && _.has(key, 'key') && _.has(key, 'namespace');
+        return Promise.all(promises).then(rootItems => rootItems.flat());
     }
 
-    RootRegistry.prototype.addRoot = function (key) {
-        if (isKey(key) || (Array.isArray(key) && key.every(isKey))) {
-            this.providers.push(function () {
-                return key;
-            });
-        } else if (typeof key === "function") {
-            this.providers.push(key);
+    addRoot(rootItem, priority) {
+
+        if (!this._isValid(rootItem)) {
+            return;
         }
-    };
 
-    return RootRegistry;
+        this._rootItems.push({
+            priority: priority || this._openmct.priority.DEFAULT,
+            provider: typeof rootItem === 'function' ? rootItem : () => rootItem
+        });
+    }
 
-});
+    _isValid(rootItem) {
+        if (utils.isIdentifier(rootItem) || typeof rootItem === 'function') {
+            return true;
+        }
+
+        if (Array.isArray(rootItem)) {
+            return rootItem.every(utils.isIdentifier);
+        }
+
+        return false;
+    }
+}

src/api/objects/object-utils.js

@@ -55,11 +55,6 @@ define([
      */
     function parseKeyString(keyString) {
         if (isIdentifier(keyString)) {
-            // hack to workaround a bug mashing keyString into identifier.key
-            if (!keyString.namespace && keyString.key.includes(':')) {
-                return parseKeyString(keyString.key);
-            }
-
             return keyString;
         }
 
@@ -177,6 +172,7 @@ define([
     }
 
     return {
+        isIdentifier: isIdentifier,
         toOldFormat: toOldFormat,
         toNewFormat: toNewFormat,
         makeKeyString: makeKeyString,

src/api/objects/test/RootRegistrySpec.js

@@ -19,83 +19,113 @@
  * this source code distribution or the Licensing information page available
  * at runtime from the About dialog for additional information.
  *****************************************************************************/
-define([
-    '../RootRegistry'
-], function (
-    RootRegistry
-) {
-    describe('RootRegistry', function () {
-        let idA;
-        let idB;
-        let idC;
-        let registry;
 
-        beforeEach(function () {
-            idA = {
-                key: 'keyA',
-                namespace: 'something'
-            };
-            idB = {
-                key: 'keyB',
-                namespace: 'something'
-            };
-            idC = {
-                key: 'keyC',
-                namespace: 'something'
-            };
-            registry = new RootRegistry();
-        });
+import { createOpenMct, resetApplicationState } from '../../../utils/testing';
 
-        it('can register a root by key', function () {
-            registry.addRoot(idA);
+describe('RootRegistry', () => {
+    let openmct;
+    let idA;
+    let idB;
+    let idC;
+    let idD;
 
-            return registry.getRoots()
-                .then(function (roots) {
-                    expect(roots).toEqual([idA]);
-                });
-        });
+    beforeEach((done) => {
+        openmct = createOpenMct();
+        idA = {
+            key: 'keyA',
+            namespace: 'something'
+        };
+        idB = {
+            key: 'keyB',
+            namespace: 'something'
+        };
+        idC = {
+            key: 'keyC',
+            namespace: 'something'
+        };
+        idD = {
+            key: 'keyD',
+            namespace: 'something'
+        };
 
-        it('can register multiple roots by key', function () {
-            registry.addRoot([idA, idB]);
+        openmct.on('start', done);
+        openmct.startHeadless();
+    });
 
-            return registry.getRoots()
-                .then(function (roots) {
-                    expect(roots).toEqual([idA, idB]);
-                });
-        });
+    afterEach(async () => {
+        await resetApplicationState(openmct);
+    });
 
-        it('can register an asynchronous root ', function () {
-            registry.addRoot(function () {
-                return Promise.resolve(idA);
+    it('can register a root by identifier', () => {
+        openmct.objects.addRoot(idA);
+
+        return openmct.objects.getRoot()
+            .then((rootObject) => {
+                expect(rootObject.composition).toEqual([idA]);
             });
+    });
 
-            return registry.getRoots()
-                .then(function (roots) {
-                    expect(roots).toEqual([idA]);
-                });
-        });
+    it('can register multiple roots by identifier', () => {
+        openmct.objects.addRoot([idA, idB]);
 
-        it('can register multiple asynchronous roots', function () {
-            registry.addRoot(function () {
-                return Promise.resolve([idA, idB]);
+        return openmct.objects.getRoot()
+            .then((rootObject) => {
+                expect(rootObject.composition).toEqual([idA, idB]);
             });
+    });
 
-            return registry.getRoots()
-                .then(function (roots) {
-                    expect(roots).toEqual([idA, idB]);
-                });
-        });
+    it('can register an asynchronous root ', () => {
+        openmct.objects.addRoot(() => Promise.resolve(idA));
 
-        it('can combine different types of registration', function () {
-            registry.addRoot([idA, idB]);
-            registry.addRoot(function () {
-                return Promise.resolve([idC]);
+        return openmct.objects.getRoot()
+            .then((rootObject) => {
+                expect(rootObject.composition).toEqual([idA]);
             });
+    });
 
-            return registry.getRoots()
-                .then(function (roots) {
-                    expect(roots).toEqual([idA, idB, idC]);
-                });
-        });
+    it('can register multiple asynchronous roots', () => {
+        openmct.objects.addRoot(() => Promise.resolve([idA, idB]));
+
+        return openmct.objects.getRoot()
+            .then((rootObject) => {
+                expect(rootObject.composition).toEqual([idA, idB]);
+            });
+    });
+
+    it('can combine different types of registration', () => {
+        openmct.objects.addRoot([idA, idB]);
+        openmct.objects.addRoot(() => Promise.resolve([idC]));
+
+        return openmct.objects.getRoot()
+            .then((rootObject) => {
+                expect(rootObject.composition).toEqual([idA, idB, idC]);
+            });
+    });
+
+    it('supports priority ordering for identifiers', () => {
+        openmct.objects.addRoot(idA, openmct.priority.LOW);
+        openmct.objects.addRoot(idB, openmct.priority.HIGH);
+        openmct.objects.addRoot(idC); // DEFAULT
+
+        return openmct.objects.getRoot()
+            .then((rootObject) => {
+                expect(rootObject.composition[0]).toEqual(idB);
+                expect(rootObject.composition[1]).toEqual(idC);
+                expect(rootObject.composition[2]).toEqual(idA);
+            });
+    });
+
+    it('supports priority ordering for different types of registration', () => {
+        openmct.objects.addRoot(() => Promise.resolve([idC]), openmct.priority.LOW);
+        openmct.objects.addRoot(idB, openmct.priority.HIGH);
+        openmct.objects.addRoot([idA, idD]); // default
+
+        return openmct.objects.getRoot()
+            .then((rootObject) => {
+                expect(rootObject.composition[0]).toEqual(idB);
+                expect(rootObject.composition[1]).toEqual(idA);
+                expect(rootObject.composition[2]).toEqual(idD);
+                expect(rootObject.composition[3]).toEqual(idC);
+            });
     });
 });

src/api/telemetry/TelemetryCollection.js

@@ -326,11 +326,11 @@ export class TelemetryCollection extends EventEmitter {
         let domain = domains.find((d) => d.key === timeSystem.key);
 
         if (domain === undefined) {
-            this._warn(ERRORS.TIMESYSTEM_KEY);
+            this._error(ERRORS.TIMESYSTEM_KEY);
         }
 
         // timeKey is used to create a dummy datum used for sorting
-        this.timeKey = domain.source || timeSystem.key; // this defaults to key if no source is set
+        this.timeKey = domain.source; // this defaults to key if no source is set
         let metadataValue = this.metadata.value(timeSystem.key) || { format: timeSystem.key };
         let valueFormatter = this.openmct.telemetry.getValueFormatter(metadataValue);
 
@@ -400,8 +400,4 @@ export class TelemetryCollection extends EventEmitter {
     _error(message) {
         throw new Error(message);
     }
-
-    _warn(message) {
-        console.warn(message);
-    }
 }

src/end.frag

@@ -1,2 +0,0 @@
-    return require('openmct');
-}));

src/plugins/condition/ConditionSetViewProvider.js

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

src/plugins/formActions/CreateAction.js

@@ -66,11 +66,10 @@ export default class CreateAction extends PropertiesAction {
         });
 
         const parentDomainObject = parentDomainObjectPath[0];
-        const namespace = parentDomainObject.identifier.namespace || parentDomainObject.key || '';
 
         this.domainObject.modified = Date.now();
         this.domainObject.location = this.openmct.objects.makeKeyString(parentDomainObject.identifier);
-        this.domainObject.identifier.namespace = namespace;
+        this.domainObject.identifier.namespace = parentDomainObject.identifier.namespace;
 
         // Show saving progress dialog
         let dialog = this.openmct.overlays.progressDialog({
@@ -100,7 +99,6 @@ export default class CreateAction extends PropertiesAction {
      */
     async _navigateAndEdit(domainObject, parentDomainObjectpath) {
         let objectPath;
-        let self = this;
         if (parentDomainObjectpath) {
             objectPath = parentDomainObjectpath && [domainObject].concat(parentDomainObjectpath);
         } else {
@@ -108,22 +106,17 @@ export default class CreateAction extends PropertiesAction {
         }
 
         const url = '#/browse/' + objectPath
-            .map(object => object && this.openmct.objects.makeKeyString(object.identifier))
+            .map(object => object && this.openmct.objects.makeKeyString(object.identifier.key))
             .reverse()
             .join('/');
 
-        function editObject() {
-            const objectView = self.openmct.objectViews.get(domainObject, objectPath)[0];
-            const canEdit = objectView && objectView.canEdit && objectView.canEdit(domainObject, objectPath);
-
-            if (canEdit) {
-                self.openmct.editor.edit();
-            }
-        }
-
-        this.openmct.router.once('afterNavigation', editObject);
-
         this.openmct.router.navigate(url);
+
+        const objectView = this.openmct.objectViews.get(domainObject, objectPath)[0];
+        const canEdit = objectView && objectView.canEdit && objectView.canEdit(domainObject, objectPath);
+        if (canEdit) {
+            this.openmct.editor.edit();
+        }
     }
 
     /**

src/plugins/imagery/components/ImageryTimeView.vue

@@ -65,8 +65,13 @@ export default {
             keyString: undefined
         };
     },
+    computed: {
+        imageHistorySize() {
+            return this.imageHistory.length;
+        }
+    },
     watch: {
-        imageHistory(newHistory, oldHistory) {
+        imageHistorySize(newSize, oldSize) {
             this.updatePlotImagery();
         }
     },

src/plugins/imagery/components/ImageryView.vue

@@ -240,6 +240,9 @@ export default {
         };
     },
     computed: {
+        imageHistorySize() {
+            return this.imageHistory.length;
+        },
         compassRoseSizingClasses() {
             let compassRoseSizingClasses = '';
             if (this.sizedImageDimensions.width < 300) {
@@ -406,23 +409,19 @@ export default {
         }
     },
     watch: {
-        imageHistory: {
-            handler(newHistory, oldHistory) {
-                const newSize = newHistory.length;
-                let imageIndex;
-                if (this.focusedImageTimestamp !== undefined) {
-                    const foundImageIndex = this.imageHistory.findIndex(image => {
-                        return image.time === this.focusedImageTimestamp;
-                    });
-                    imageIndex = foundImageIndex > -1 ? foundImageIndex : newSize - 1;
-                } else {
-                    imageIndex = newSize > 0 ? newSize - 1 : undefined;
-                }
+        imageHistorySize(newSize, oldSize) {
+            let imageIndex;
+            if (this.focusedImageTimestamp !== undefined) {
+                const foundImageIndex = this.imageHistory.findIndex(image => {
+                    return image.time === this.focusedImageTimestamp;
+                });
+                imageIndex = foundImageIndex > -1 ? foundImageIndex : newSize - 1;
+            } else {
+                imageIndex = newSize > 0 ? newSize - 1 : undefined;
+            }
 
-                this.setFocusedImage(imageIndex, false);
-                this.scrollToRight();
-            },
-            deep: true
+            this.setFocusedImage(imageIndex, false);
+            this.scrollToRight();
         },
         focusedImageIndex() {
             this.trackDuration();
@@ -511,6 +510,12 @@ export default {
                 this.timeContext.off("clock", this.trackDuration);
             }
         },
+        boundsChange(bounds, isTick) {
+            if (!isTick) {
+                this.previousFocusedImage = this.focusedImage ? JSON.parse(JSON.stringify(this.focusedImage)) : undefined;
+                this.requestHistory();
+            }
+        },
         expand() {
             const actionCollection = this.openmct.actions.getActionsCollection(this.objectPath, this.currentView);
             const visibleActions = actionCollection.getVisibleActions();
@@ -685,32 +690,22 @@ export default {
                 return;
             }
 
+            if (this.previousFocusedImage) {
+                // determine if the previous image exists in the new bounds of imageHistory
+                const matchIndex = this.matchIndexOfPreviousImage(
+                    this.previousFocusedImage,
+                    this.imageHistory
+                );
+                focusedIndex = matchIndex > -1 ? matchIndex : this.imageHistory.length - 1;
+
+                delete this.previousFocusedImage;
+            }
+
             if (thumbnailClick) {
                 //We use the props till the user changes what they want to see
                 this.focusedImageTimestamp = undefined;
-                //set the previousFocusedImage when a user chooses an image
-                this.previousFocusedImage = this.imageHistory[focusedIndex] ? JSON.parse(JSON.stringify(this.imageHistory[focusedIndex])) : undefined;
             }
 
-            if (this.previousFocusedImage) {
-                // determine if the previous image exists in the new bounds of imageHistory
-                if (!thumbnailClick) {
-                    const matchIndex = this.matchIndexOfPreviousImage(
-                        this.previousFocusedImage,
-                        this.imageHistory
-                    );
-                    focusedIndex = matchIndex > -1 ? matchIndex : this.imageHistory.length - 1;
-                }
-
-                if (!(this.isPaused || thumbnailClick)
-                    || focusedIndex === this.imageHistory.length - 1) {
-                    delete this.previousFocusedImage;
-                }
-            }
-
-            this.focusedImageIndex = focusedIndex;
-
-            //TODO: do we even need this anymore?
             if (this.isPaused && !thumbnailClick && this.focusedImageTimestamp === undefined) {
                 this.nextImageIndex = focusedIndex;
                 //this could happen if bounds changes
@@ -721,6 +716,8 @@ export default {
                 return;
             }
 
+            this.focusedImageIndex = focusedIndex;
+
             if (thumbnailClick && !this.isPaused) {
                 this.paused(true);
             }

src/plugins/imagery/mixins/imageryData.js

@@ -120,15 +120,9 @@ export default {
             return this.timeFormatter.parse(datum);
         },
         boundsChange(bounds, isTick) {
-            if (isTick) {
-                return;
+            if (!isTick) {
+                this.requestHistory();
             }
-
-            // forcibly reset the imageContainer size to prevent an aspect ratio distortion
-            delete this.imageContainerWidth;
-            delete this.imageContainerHeight;
-
-            return this.requestHistory();
         },
         async requestHistory() {
             let bounds = this.timeContext.bounds();

src/plugins/linkAction/LinkAction.js

@@ -91,11 +91,11 @@ export default class LinkAction {
     }
 
     validate(currentParent) {
-        return (data) => {
-            const parentCandidate = data.value[0];
+        return (object, data) => {
+            const parentCandidate = data.value;
             const currentParentKeystring = this.openmct.objects.makeKeyString(currentParent.identifier);
             const parentCandidateKeystring = this.openmct.objects.makeKeyString(parentCandidate.identifier);
-            const objectKeystring = this.openmct.objects.makeKeyString(this.object.identifier);
+            const objectKeystring = this.openmct.objects.makeKeyString(object.identifier);
 
             if (!parentCandidateKeystring || !currentParentKeystring) {
                 return false;
@@ -114,7 +114,7 @@ export default class LinkAction {
                 return false;
             }
 
-            return parentCandidate && this.openmct.composition.checkPolicy(parentCandidate, this.object);
+            return parentCandidate && this.openmct.composition.checkPolicy(parentCandidate, object);
         };
     }
 }

src/plugins/myItems/plugin.js

@@ -25,11 +25,15 @@ import myItemsInterceptor from "./myItemsInterceptor";
 
 const MY_ITEMS_DEFAULT_NAME = 'My Items';
 
-export default function MyItemsPlugin(name = MY_ITEMS_DEFAULT_NAME, namespace = '') {
+export default function MyItemsPlugin(name = MY_ITEMS_DEFAULT_NAME, namespace = '', priority = undefined) {
     return function install(openmct) {
         const identifier = createMyItemsIdentifier(namespace);
 
+        if (priority === undefined) {
+            priority = openmct.priority.LOW;
+        }
+
         openmct.objects.addGetInterceptor(myItemsInterceptor(openmct, identifier, name));
-        openmct.objects.addRoot(identifier);
+        openmct.objects.addRoot(identifier, priority);
     };
 }

src/plugins/notebook/components/Notebook.vue

@@ -142,6 +142,7 @@ import { clearDefaultNotebook, getDefaultNotebook, setDefaultNotebook, setDefaul
 import { addNotebookEntry, createNewEmbed, getEntryPosById, getNotebookEntries, mutateObject } from '../utils/notebook-entries';
 import { saveNotebookImageDomainObject, updateNamespaceOfDomainObject } from '../utils/notebook-image';
 import { NOTEBOOK_VIEW_TYPE } from '../notebook-constants';
+import objectUtils from 'objectUtils';
 
 import { debounce } from 'lodash';
 import objectLink from '../../../ui/mixins/object-link';
@@ -454,6 +455,11 @@ export default {
                 ? getDefaultNotebook().defaultSectionId
                 : undefined;
         },
+        getDefaultNotebookObject() {
+            const defaultNotebook = getDefaultNotebook();
+
+            return defaultNotebook && this.openmct.objects.get(defaultNotebook.identifier);
+        },
         getLinktoNotebook() {
             const objectPath = this.openmct.router.path;
             const link = objectLink.computed.objectLink.call({
@@ -613,12 +619,12 @@ export default {
 
             this.sectionsChanged({ sections });
         },
-        removeDefaultClass(defaultNotebookIdentifier) {
-            if (!defaultNotebookIdentifier) {
+        removeDefaultClass(domainObject) {
+            if (!domainObject) {
                 return;
             }
 
-            this.openmct.status.delete(defaultNotebookIdentifier);
+            this.openmct.status.delete(domainObject.identifier);
         },
         resetSearch() {
             this.search = '';
@@ -627,16 +633,15 @@ export default {
         toggleNav() {
             this.showNav = !this.showNav;
         },
-        updateDefaultNotebook(notebookStorage) {
-            const defaultNotebook = getDefaultNotebook();
-            const defaultNotebookIdentifier = defaultNotebook && defaultNotebook.identifier;
-            const isSameNotebook = defaultNotebookIdentifier
-                && this.openmct.objects.areIdsEqual(defaultNotebookIdentifier, notebookStorage.identifier);
+        async updateDefaultNotebook(notebookStorage) {
+            const defaultNotebookObject = await this.getDefaultNotebookObject();
+            const isSameNotebook = defaultNotebookObject
+                && objectUtils.makeKeyString(defaultNotebookObject.identifier) === objectUtils.makeKeyString(notebookStorage.identifier);
             if (!isSameNotebook) {
-                this.removeDefaultClass(defaultNotebookIdentifier);
+                this.removeDefaultClass(defaultNotebookObject);
             }
 
-            if (!defaultNotebookIdentifier || !isSameNotebook) {
+            if (!defaultNotebookObject || !isSameNotebook) {
                 setDefaultNotebook(this.openmct, notebookStorage, this.domainObject);
             }
 

src/plugins/notebook/snapshot.js

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

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

@@ -105,6 +105,11 @@ export function addNotebookEntry(openmct, domainObject, notebookStorage, embed =
     const date = Date.now();
     const configuration = domainObject.configuration;
     const entries = configuration.entries || {};
+
+    if (!entries) {
+        return;
+    }
+
     const embeds = embed
         ? [embed]
         : [];
@@ -120,8 +125,7 @@ export function addNotebookEntry(openmct, domainObject, notebookStorage, embed =
     const newEntries = addEntryIntoPage(notebookStorage, entries, entry);
 
     addDefaultClass(domainObject, openmct);
-
-    mutateObject(openmct, domainObject, 'configuration.entries', newEntries);
+    domainObject.configuration.entries = newEntries;
 
     return id;
 }

src/plugins/plot/chart/MctChart.vue

@@ -278,7 +278,7 @@ export default {
             // Have to throw away the old canvas elements and replace with new
             // canvas elements in order to get new drawing contexts.
             const div = document.createElement('div');
-            div.innerHTML = this.canvasTemplate + this.canvasTemplate;
+            div.innerHTML = this.TEMPLATE;
             const mainCanvas = div.querySelectorAll("canvas")[1];
             const overlayCanvas = div.querySelectorAll("canvas")[0];
             this.canvas.parentNode.replaceChild(mainCanvas, this.canvas);

src/plugins/summaryWidget/SummaryWidgetsCompositionPolicy.js

@@ -29,9 +29,7 @@ define(
         }
 
         SummaryWidgetsCompositionPolicy.prototype.allow = function (parent, child) {
-            const parentType = parent.type;
-
-            if (parentType === 'summary-widget' && !this.openmct.telemetry.isTelemetryObject(child)) {
+            if (parent.type === 'summary-widget' && !this.openmct.telemetry.isTelemetryObject(child)) {
                 return false;
             }
 

src/start.frag

@@ -1,45 +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.
- *
- * Open MCT https://nasa.github.io/openmct/
- * Version: @@version
- * Built: @@timestamp
- * Revision: @@revision
- * Branch: @@branch
- *
- * @preserve
- *****************************************************************************/
-
-(function (root, factory) {
-    if (typeof define === 'function' && define.amd) {
-        define([], factory);
-    } else if (typeof exports === 'object') {
-        module.exports = factory();
-    } else {
-        root.openmct = factory();
-    }
-}(this, function() {
-    var BUILD_CONSTANTS = {
-        version: "@@version",
-        timestamp: "@@timestamp",
-        revision: "@@revision",
-        branch: "@@branch"
-    };

src/styles/_global.scss

@@ -229,7 +229,7 @@ body.desktop .has-local-controls {
     @include abs();
 }
 
-.c-grid {
+.c-grid .c-grid {
     pointer-events: none;
 
     &__x  { @include bgTicks($editUIGridColorFg, 'x'); }

src/ui/color/ColorHelper.js

@@ -21,7 +21,7 @@
  *****************************************************************************/
 
 export const COLOR_PALETTE = [
-    [0x43, 0xB0, 0xFF],
+    [0x00, 0x37, 0xFF],
     [0xF0, 0x60, 0x00],
     [0x00, 0x70, 0x40],
     [0xFB, 0x49, 0x49],
@@ -30,25 +30,25 @@ export const COLOR_PALETTE = [
     [0xFF, 0xA6, 0x3D],
     [0x05, 0xA3, 0x00],
     [0xF0, 0x00, 0x6C],
-    [0xAC, 0x54, 0xAE],
+    [0x77, 0x17, 0x7A],
     [0x23, 0xA9, 0xDB],
-    [0xC7, 0xBE, 0x52],
-    [0x5A, 0xBD, 0x56],
+    [0xFA, 0xF0, 0x6F],
+    [0x4E, 0xF0, 0x48],
     [0xAD, 0x50, 0x72],
     [0x94, 0x25, 0xEA],
     [0x21, 0x87, 0x82],
     [0x8F, 0x6E, 0x47],
     [0xf0, 0x59, 0xcb],
     [0x34, 0xB6, 0x7D],
-    [0x7F, 0x52, 0xFF],
-    [0x46, 0xC7, 0xC0],
+    [0x6A, 0x36, 0xFF],
+    [0x56, 0xF0, 0xE8],
     [0xA1, 0x8C, 0x1C],
-    [0x95, 0xB1, 0x26],
+    [0xCB, 0xE1, 0x44],
     [0xFF, 0x84, 0x9E],
     [0xB7, 0x79, 0xE7],
     [0x8C, 0xC9, 0xFD],
     [0xDB, 0xAA, 0x6E],
-    [0x93, 0xB5, 0x77],
+    [0xB8, 0xDF, 0x97],
     [0xFF, 0xBC, 0xDA],
     [0xD3, 0xB6, 0xDE]
 ];

src/ui/components/ObjectView.vue

@@ -141,15 +141,11 @@ export default {
             this.openmct.objectViews.off('clearData', this.clearData);
         },
         getStyleReceiver() {
-            let styleReceiver;
+            let styleReceiver = this.$refs.objectViewWrapper.querySelector('.js-style-receiver')
+                || this.$refs.objectViewWrapper.querySelector(':first-child');
 
-            if (this.$refs.objectViewWrapper !== undefined) {
-                styleReceiver = this.$refs.objectViewWrapper.querySelector('.js-style-receiver')
-                  || this.$refs.objectViewWrapper.querySelector(':first-child');
-
-                if (styleReceiver === null) {
-                    styleReceiver = undefined;
-                }
+            if (styleReceiver === null) {
+                styleReceiver = undefined;
             }
 
             return styleReceiver;

src/ui/inspector/details/Properties.vue

@@ -186,10 +186,6 @@ export default {
                     return {
                         name: field.name,
                         value: field.path.reduce((object, key) => {
-                            if (object === undefined) {
-                                return object;
-                            }
-
                             return object[key];
                         }, this.domainObject)
                     };

src/ui/layout/mct-tree.vue

@@ -445,10 +445,6 @@ export default {
             }
 
             // sorting composition items
-            if (!a.name || !b.name) {
-                return 0;
-            }
-
             if (a.name.toLowerCase()
                 > b.name.toLowerCase()) {
                 return 1;

src/ui/mixins/object-link.js

@@ -1,4 +1,4 @@
-import objectPathToUrl from '../../tools/url';
+import objectPathToUrl from '/src/tools/url';
 
 export default {
     inject: ['openmct'],